elasticsearch-model 0.0.1 → 0.1.0.rc1

data/test/test_helper.rb

@@ -0,0 +1,57 @@
+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
+
+require 'test/unit'
+require 'shoulda-context'
+require 'mocha/setup'
+require 'turn' unless ENV["TM_FILEPATH"] || ENV["NOTURN"] || RUBY_1_8
+
+require 'ansi'
+require 'oj'
+
+require 'active_record'
+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| "#{m.ansi(:faint, :cyan)}\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:9250',
+                                                                tracer: (ENV['QUIET'] ? nil : tracer)
+      end
+    end
+  end
+end

data/test/unit/adapter_active_record_test.rb

@@ -0,0 +1,93 @@
+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)
+    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', where: @records))
+
+        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', 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 = DummyClassForActiveRecord.new
+        instance.expects(:klass).returns(stub('class', 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
+      should "implement the __find_in_batches method" do
+        DummyClassForActiveRecord.expects(:find_in_batches).returns([])
+
+        DummyClassForActiveRecord.__send__ :extend, Elasticsearch::Model::Adapter::ActiveRecord::Importing
+        DummyClassForActiveRecord.__find_in_batches do; end
+      end
+    end
+
+  end
+end

data/test/unit/adapter_default_test.rb

@@ -0,0 +1,31 @@
+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
+
+    should "have the default Importing implementation" do
+      DummyClassForDefaultAdapter.__send__ :include, Elasticsearch::Model::Adapter::Default::Importing
+
+      assert_raise Elasticsearch::Model::NotImplemented do
+        DummyClassForDefaultAdapter.new.__find_in_batches
+      end
+    end
+
+  end
+end

data/test/unit/adapter_mongoid_test.rb

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

data/test/unit/importing_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
+  context "Importing module" do
+    class ::DummyImportingModel
+    end
+
+    module ::DummyImportingAdapter
+      module ImportingMixin
+        def __find_in_batches(options={}, &block)
+          yield if block_given?
+        end
+      end
+
+      def importing_mixin
+        ImportingMixin
+      end; module_function :importing_mixin
+    end
+
+    should "include methods from the module and adapter" do
+      Elasticsearch::Model::Adapter.expects(:from_class)
+                                   .with(DummyImportingModel)
+                                   .returns(DummyImportingAdapter)
+
+      DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
+
+      assert_respond_to DummyImportingModel, :import
+      assert_respond_to DummyImportingModel, :__find_in_batches
+    end
+
+    should "call the client when importing" do
+      Elasticsearch::Model::Adapter.expects(:from_class)
+                                   .with(DummyImportingModel)
+                                   .returns(DummyImportingAdapter)
+
+      DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
+
+      client = mock('client')
+      client.expects(:bulk).returns({'items' => []})
+
+      DummyImportingModel.expects(:client).returns(client)
+      DummyImportingModel.expects(:index_name).returns('foo')
+      DummyImportingModel.expects(:document_type).returns('foo')
+
+      assert_equal 0, DummyImportingModel.import
+    end
+
+    should "return number of errors" do
+      Elasticsearch::Model::Adapter.expects(:from_class)
+                                   .with(DummyImportingModel)
+                                   .returns(DummyImportingAdapter)
+
+      DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
+
+      client = mock('client')
+      client.expects(:bulk).returns({'items' => [ {'index' => {}}, {'index' => {'error' => 'FAILED'}} ]})
+
+      DummyImportingModel.stubs(:client).returns(client)
+      DummyImportingModel.stubs(:index_name).returns('foo')
+      DummyImportingModel.stubs(:document_type).returns('foo')
+
+      assert_equal 1, DummyImportingModel.import
+    end
+
+    should "yield the response" do
+      Elasticsearch::Model::Adapter.expects(:from_class)
+                                   .with(DummyImportingModel)
+                                   .returns(DummyImportingAdapter)
+
+      DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
+
+      client = mock('client')
+      client.expects(:bulk).returns({'items' => [ {'index' => {}}, {'index' => {'error' => 'FAILED'}} ]})
+
+      DummyImportingModel.stubs(:client).returns(client)
+      DummyImportingModel.stubs(:index_name).returns('foo')
+      DummyImportingModel.stubs(:document_type).returns('foo')
+
+      DummyImportingModel.import do |response|
+        assert_equal 2, response['items'].size
+      end
+    end
+
+    should "delete and create the index with the force option" do
+      DummyImportingModel.expects(:__find_in_batches).with do |options|
+        assert_equal 'bar', options[:foo]
+        assert_nil   options[:force]
+      end
+
+      DummyImportingModel.expects(:create_index!).with do |options|
+        assert_equal true, options[:force]
+      end
+
+      DummyImportingModel.import force: true, foo: 'bar'
+    end
+  end
+end