elasticsearch-model-queryable 0.1.5

data/test/integration/mongoid_basic_test.rb

@@ -0,0 +1,193 @@
+require 'test_helper'
+
+begin
+  require 'mongoid'
+  session = Moped::Connection.new("localhost", 27017, 0.5)
+  session.connect
+  ENV["MONGODB_AVAILABLE"] = 'yes'
+rescue LoadError, Moped::Errors::ConnectionFailure => e
+  $stderr.puts "MongoDB not installed or running: #{e}"
+end
+
+if ENV["MONGODB_AVAILABLE"]
+  $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']
+  Moped.logger   = logger unless ENV['QUIET']
+
+  Mongoid.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.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/test_helper.rb

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

data/test/unit/adapter_active_record_test.rb

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

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

@@ -0,0 +1,102 @@
+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
+        DummyClassForMongoid.expects(:all).returns([])
+
+        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_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class Elasticsearch::Model::AdapterTest < Test::Unit::TestCase
+  context "Adapter module" do
+    class ::DummyAdapterClass; end
+    class ::DummyAdapterClassWithAdapter; end
+    class ::DummyAdapter
+      Records   = Module.new
+      Callbacks = Module.new
+      Importing = Module.new
+    end
+
+    should "return an Adapter instance" do
+      assert_instance_of Elasticsearch::Model::Adapter::Adapter,
+                         Elasticsearch::Model::Adapter.from_class(DummyAdapterClass)
+    end
+
+    should "return a list of adapters" do
+      Elasticsearch::Model::Adapter::Adapter.expects(:adapters)
+      Elasticsearch::Model::Adapter.adapters
+    end
+
+    should "register an adapter" do
+      begin
+        Elasticsearch::Model::Adapter::Adapter.expects(:register)
+        Elasticsearch::Model::Adapter.register(:foo, lambda { |c| false })
+      ensure
+        Elasticsearch::Model::Adapter::Adapter.instance_variable_set(:@adapters, {})
+      end
+    end
+  end
+
+  context "Adapter class" do
+    should "register an adapter" do
+      begin
+        Elasticsearch::Model::Adapter::Adapter.register(:foo, lambda { |c| false })
+        assert Elasticsearch::Model::Adapter::Adapter.adapters[:foo]
+      ensure
+        Elasticsearch::Model::Adapter::Adapter.instance_variable_set(:@adapters, {})
+      end
+    end
+
+    should "return the default adapter" do
+      adapter = Elasticsearch::Model::Adapter::Adapter.new(DummyAdapterClass)
+      assert_equal Elasticsearch::Model::Adapter::Default, adapter.adapter
+    end
+
+    should "return a specific adapter" do
+      Elasticsearch::Model::Adapter::Adapter.register(DummyAdapter,
+                                                      lambda { |c| c == DummyAdapterClassWithAdapter })
+
+      adapter = Elasticsearch::Model::Adapter::Adapter.new(DummyAdapterClassWithAdapter)
+      assert_equal DummyAdapter, adapter.adapter
+    end
+
+    should "return the modules" do
+      assert_nothing_raised do
+        Elasticsearch::Model::Adapter::Adapter.register(DummyAdapter,
+                                                      lambda { |c| c == DummyAdapterClassWithAdapter })
+
+        adapter = Elasticsearch::Model::Adapter::Adapter.new(DummyAdapterClassWithAdapter)
+
+        assert_instance_of Module, adapter.records_mixin
+        assert_instance_of Module, adapter.callbacks_mixin
+        assert_instance_of Module, adapter.importing_mixin
+      end
+    end
+  end
+end

data/test/unit/callbacks_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class Elasticsearch::Model::CallbacksTest < Test::Unit::TestCase
+  context "Callbacks module" do
+    class ::DummyCallbacksModel
+    end
+
+    module DummyCallbacksAdapter
+      module CallbacksMixin
+      end
+
+      def callbacks_mixin
+        CallbacksMixin
+      end; module_function :callbacks_mixin
+    end
+
+    should "include the callbacks mixin from adapter" do
+      Elasticsearch::Model::Adapter.expects(:from_class)
+                                   .with(DummyCallbacksModel)
+                                   .returns(DummyCallbacksAdapter)
+
+      ::DummyCallbacksModel.expects(:__send__).with do |method, parameter|
+        assert_equal :include, method
+        assert_equal DummyCallbacksAdapter::CallbacksMixin, parameter
+        true
+      end
+
+      Elasticsearch::Model::Callbacks.included(DummyCallbacksModel)
+    end
+  end
+end

data/test/unit/client_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class Elasticsearch::Model::ClientTest < Test::Unit::TestCase
+  context "Client module" do
+    class ::DummyClientModel
+      extend  Elasticsearch::Model::Client::ClassMethods
+      include Elasticsearch::Model::Client::InstanceMethods
+    end
+
+    should "have the default client method" do
+      assert_instance_of Elasticsearch::Transport::Client, DummyClientModel.client
+      assert_instance_of Elasticsearch::Transport::Client, DummyClientModel.new.client
+    end
+
+    should "set the client for the model" do
+      DummyClientModel.client = 'foobar'
+      assert_equal 'foobar', DummyClientModel.client
+      assert_equal 'foobar', DummyClientModel.new.client
+    end
+
+    should "set the client for a model instance" do
+      instance = DummyClientModel.new
+      instance.client = 'moobam'
+      assert_equal 'moobam', instance.client
+    end
+  end
+end