elasticsearch-model 0.1.7 → 0.1.8

data/lib/elasticsearch/model/response/results.rb

@@ -22,7 +22,7 @@ module Elasticsearch
         #
         def results
           # TODO: Configurable custom wrapper
-          @results  = response.response['hits']['hits'].map { |hit| Result.new(hit) }
+          response.response['hits']['hits'].map { |hit| Result.new(hit) }
         end
 
       end

data/lib/elasticsearch/model/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Model
-    VERSION = "0.1.7"
+    VERSION = "0.1.8"
   end
 end

data/test/integration/active_record_basic_test.rb

@@ -11,6 +11,7 @@ module Elasticsearch
           ActiveRecord::Schema.define(:version => 1) do
             create_table :articles do |t|
               t.string   :title
+              t.string   :body
               t.datetime :created_at, :default => 'NOW()'
             end
           end
@@ -22,6 +23,7 @@ module Elasticsearch
             settings index: { number_of_shards: 1, number_of_replicas: 0 } do
               mapping do
                 indexes :title,      type: 'string', analyzer: 'snowball'
+                indexes :body,       type: 'string'
                 indexes :created_at, type: 'date'
               end
             end
@@ -30,9 +32,9 @@ module Elasticsearch
           Article.delete_all
           Article.__elasticsearch__.create_index! force: true
 
-          ::Article.create! title: 'Test'
-          ::Article.create! title: 'Testing Coding'
-          ::Article.create! title: 'Coding'
+          ::Article.create! title: 'Test',           body: ''
+          ::Article.create! title: 'Testing Coding', body: ''
+          ::Article.create! title: 'Coding',         body: ''
 
           Article.__elasticsearch__.refresh_index!
         end
@@ -128,7 +130,7 @@ module Elasticsearch
           assert_equal 1, response.records.size
         end
 
-         should "update specific attributes" do
+        should "update specific attributes" do
           article = Article.first
 
           response = Article.search 'title:special'
@@ -146,6 +148,29 @@ module Elasticsearch
           assert_equal 1, response.records.size
         end
 
+        should "update document when save is called multiple times in a transaction" do
+          article = Article.first
+          response = Article.search 'body:dummy'
+
+          assert_equal 0, response.results.size
+          assert_equal 0, response.records.size
+
+          ActiveRecord::Base.transaction do
+            article.body = 'dummy'
+            article.save
+
+            article.title = 'special'
+            article.save
+          end
+
+          article.__elasticsearch__.update_document
+          Article.__elasticsearch__.refresh_index!
+
+          response = Article.search 'body:dummy'
+          assert_equal 1, response.results.size
+          assert_equal 1, response.records.size
+        end
+
         should "return results for a DSL search" do
           response = Article.search query: { match: { title: { query: 'test' } } }
 

data/test/integration/multiple_models_test.rb

@@ -20,28 +20,28 @@ module Elasticsearch
             end
           end
 
-          class ::Episode < ActiveRecord::Base
-            include Elasticsearch::Model
-            include Elasticsearch::Model::Callbacks
+          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: 'string', analyzer: 'snowball'
-                indexes :created_at, type: 'date'
+              settings index: {number_of_shards: 1, number_of_replicas: 0} do
+                mapping do
+                  indexes :name, type: 'string', analyzer: 'snowball'
+                  indexes :created_at, type: 'date'
+                end
               end
             end
           end
 
-          class ::Series < ActiveRecord::Base
-            include Elasticsearch::Model
-            include Elasticsearch::Model::Callbacks
+          class ::Episode < ActiveRecord::Base
+            include NameSearch
+          end
 
-            settings index: {number_of_shards: 1, number_of_replicas: 0} do
-              mapping do
-                indexes :name, type: 'string', analyzer: 'snowball'
-                indexes :created_at, type: 'date'
-              end
-            end
+          class ::Series < ActiveRecord::Base
+            include NameSearch
           end
 
           [::Episode, ::Series].each do |model|
@@ -56,7 +56,7 @@ module Elasticsearch
         end
 
         should "find matching documents across multiple models" do
-          response = Elasticsearch::Model.search("greatest", [Series, Episode])
+          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}"
 
@@ -75,22 +75,40 @@ module Elasticsearch
         end
 
         should "provide access to results" do
-          q = {query: {query_string: {query: 'A great *'}}, highlight: {fields: {name: {}}}}
-          response = Elasticsearch::Model.search(q, [Series, Episode])
+          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 true,              response.results[0].highlight?
-          assert_equal true,              response.results[0].highlight.name?
-          assert_equal false,             response.results[0].highlight.boo?
 
           assert_equal 'A great Series', response.results[1].name
           assert_equal true,             response.results[1].name?
           assert_equal false,            response.results[1].boo?
-          assert_equal true,             response.results[1].highlight?
-          assert_equal true,             response.results[1].highlight.name?
-          assert_equal false,            response.results[1].highlight.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 Mongo.available?
@@ -128,7 +146,7 @@ module Elasticsearch
             end
 
             should "find matching documents across multiple models" do
-              response = Elasticsearch::Model.search("greatest", [Episode, Image])
+              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}"
 

data/test/support/model.json

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

data/test/support/model.yml

@@ -0,0 +1,2 @@
+baz:
+  'qux'

data/test/unit/adapter_mongoid_test.rb

@@ -76,7 +76,9 @@ class Elasticsearch::Model::AdapterMongoidTest < Test::Unit::TestCase
 
     context "Importing" do
       should "implement the __find_in_batches method" do
-        DummyClassForMongoid.expects(:all).returns([])
+        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

data/test/unit/importing_test.rb

@@ -44,6 +44,7 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
       DummyImportingModel.expects(:client).returns(client)
       DummyImportingModel.expects(:index_name).returns('foo')
       DummyImportingModel.expects(:document_type).returns('foo')
+      DummyImportingModel.stubs(:index_exists?).returns(true)
       DummyImportingModel.stubs(:__batch_to_bulk)
       assert_equal 0, DummyImportingModel.import
     end
@@ -61,6 +62,7 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
       DummyImportingModel.stubs(:client).returns(client)
       DummyImportingModel.stubs(:index_name).returns('foo')
       DummyImportingModel.stubs(:document_type).returns('foo')
+      DummyImportingModel.stubs(:index_exists?).returns(true)
       DummyImportingModel.stubs(:__batch_to_bulk)
 
       assert_equal 1, DummyImportingModel.import
@@ -79,6 +81,7 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
       DummyImportingModel.stubs(:client).returns(client)
       DummyImportingModel.stubs(:index_name).returns('foo')
       DummyImportingModel.stubs(:document_type).returns('foo')
+      DummyImportingModel.stubs(:index_exists?).returns(true)
       DummyImportingModel.stubs(:__batch_to_bulk)
 
       assert_equal [{'index' => {'error' => 'FAILED'}}], DummyImportingModel.import(return: 'errors')
@@ -97,6 +100,7 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
       DummyImportingModel.stubs(:client).returns(client)
       DummyImportingModel.stubs(:index_name).returns('foo')
       DummyImportingModel.stubs(:document_type).returns('foo')
+      DummyImportingModel.stubs(:index_exists?).returns(true)
       DummyImportingModel.stubs(:__batch_to_bulk)
 
       DummyImportingModel.import do |response|
@@ -104,22 +108,42 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
       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]
-        true
-      end
+    context "when the index does not exist" do
+      should "raise an exception" do
+        Elasticsearch::Model::Adapter.expects(:from_class)
+                                     .with(DummyImportingModel)
+                                     .returns(DummyImportingAdapter)
+
+        DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
+
+        DummyImportingModel.expects(:index_name).returns('foo')
+        DummyImportingModel.expects(:document_type).returns('foo')
+        DummyImportingModel.expects(:index_exists?).returns(false)
 
-      DummyImportingModel.expects(:create_index!).with do |options|
-        assert_equal true, options[:force]
-        true
+        assert_raise ArgumentError do
+          DummyImportingModel.import
+        end
       end
+    end
 
-      DummyImportingModel.expects(:index_name).returns('foo')
-      DummyImportingModel.expects(:document_type).returns('foo')
+    context "with the force option" do
+      should "delete and create the index" do
+        DummyImportingModel.expects(:__find_in_batches).with do |options|
+          assert_equal 'bar', options[:foo]
+          assert_nil   options[:force]
+          true
+        end
+
+        DummyImportingModel.expects(:create_index!).with do |options|
+          assert_equal true, options[:force]
+          true
+        end
+
+        DummyImportingModel.expects(:index_name).returns('foo')
+        DummyImportingModel.expects(:document_type).returns('foo')
 
-      DummyImportingModel.import force: true, foo: 'bar'
+        DummyImportingModel.import force: true, foo: 'bar'
+      end
     end
 
     should "allow passing a different index / type" do
@@ -141,6 +165,7 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
         .returns({'items' => [ {'index' => {} }]})
 
       DummyImportingModel.stubs(:client).returns(client)
+      DummyImportingModel.stubs(:index_exists?).returns(true)
       DummyImportingModel.stubs(:__batch_to_bulk)
 
       DummyImportingModel.import index: 'my-new-index', type: 'my-other-type'
@@ -151,6 +176,7 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
       transform = lambda {|a|}
 
       DummyImportingModel.stubs(:client).returns(client)
+      DummyImportingModel.stubs(:index_exists?).returns(true)
       DummyImportingModel.expects(:__transform).returns(transform)
       DummyImportingModel.expects(:__batch_to_bulk).with(anything, transform)
 
@@ -162,6 +188,7 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
       transform = lambda {|a|}
 
       DummyImportingModel.stubs(:client).returns(client)
+      DummyImportingModel.stubs(:index_exists?).returns(true)
       DummyImportingModel.expects(:__batch_to_bulk).with(anything, transform)
 
       DummyImportingModel.import index: 'foo', type: 'bar', transform: transform

data/test/unit/indexing_test.rb

@@ -28,13 +28,27 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         assert_instance_of Elasticsearch::Model::Indexing::Settings, DummyIndexingModel.settings
       end
 
-      should "update and return the index settings" do
+      should "update and return the index settings from a hash" do
         DummyIndexingModel.settings foo: 'boo'
         DummyIndexingModel.settings bar: 'bam'
 
         assert_equal( {foo: 'boo', bar: 'bam'},  DummyIndexingModel.settings.to_hash)
       end
 
+      should "update and return the index settings from a yml file" do
+        DummyIndexingModel.settings File.open("test/support/model.yml")
+        DummyIndexingModel.settings bar: 'bam'
+
+        assert_equal( {foo: 'boo', bar: 'bam', 'baz' => 'qux'}, DummyIndexingModel.settings.to_hash)
+      end
+
+      should "update and return the index settings from a json file" do
+        DummyIndexingModel.settings File.open("test/support/model.json")
+        DummyIndexingModel.settings bar: 'bam'
+
+        assert_equal( {foo: 'boo', bar: 'bam', 'baz' => 'qux'}, DummyIndexingModel.settings.to_hash)
+      end
+
       should "evaluate the block" do
         DummyIndexingModel.expects(:foo)
 
@@ -76,6 +90,28 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         assert_equal 'string', mappings.to_hash[:mytype][:properties][:bar][:type]
       end
 
+      should "define multiple fields" do
+        mappings = Elasticsearch::Model::Indexing::Mappings.new :mytype
+
+        mappings.indexes :foo_1, type: 'string' do
+          indexes :raw, analyzer: 'keyword'
+        end
+
+        mappings.indexes :foo_2, type: 'multi_field' do
+          indexes :raw, analyzer: 'keyword'
+        end
+
+        assert_equal 'string',  mappings.to_hash[:mytype][:properties][:foo_1][:type]
+        assert_equal 'string',  mappings.to_hash[:mytype][:properties][:foo_1][:fields][:raw][:type]
+        assert_equal 'keyword', mappings.to_hash[:mytype][:properties][:foo_1][:fields][:raw][:analyzer]
+        assert_nil              mappings.to_hash[:mytype][:properties][:foo_1][:properties]
+
+        assert_equal 'multi_field',  mappings.to_hash[:mytype][:properties][:foo_2][:type]
+        assert_equal 'string',  mappings.to_hash[:mytype][:properties][:foo_2][:fields][:raw][:type]
+        assert_equal 'keyword', mappings.to_hash[:mytype][:properties][:foo_2][:fields][:raw][:analyzer]
+        assert_nil              mappings.to_hash[:mytype][:properties][:foo_2][:properties]
+      end
+
       should "define embedded properties" do
         mappings = Elasticsearch::Model::Indexing::Mappings.new :mytype
 
@@ -83,20 +119,27 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
           indexes :bar
         end
 
-        mappings.indexes :multi, type: 'multi_field' do
-          indexes :multi, analyzer: 'snowball'
-          indexes :raw,   analyzer: 'keyword'
+        mappings.indexes :foo_object, type: 'object' do
+          indexes :bar
+        end
+
+        mappings.indexes :foo_nested, type: 'nested' do
+          indexes :bar
         end
 
+        # Object is the default when `type` is missing and there's a block passed
+        #
         assert_equal 'object', mappings.to_hash[:mytype][:properties][:foo][:type]
         assert_equal 'string', mappings.to_hash[:mytype][:properties][:foo][:properties][:bar][:type]
+        assert_nil             mappings.to_hash[:mytype][:properties][:foo][:fields]
 
-        assert_equal 'multi_field', mappings.to_hash[:mytype][:properties][:multi][:type]
-        assert_equal 'snowball', mappings.to_hash[:mytype][:properties][:multi][:fields][:multi][:analyzer]
-        assert_equal 'keyword',  mappings.to_hash[:mytype][:properties][:multi][:fields][:raw][:analyzer]
-      end
+        assert_equal 'object', mappings.to_hash[:mytype][:properties][:foo_object][:type]
+        assert_equal 'string', mappings.to_hash[:mytype][:properties][:foo_object][:properties][:bar][:type]
+        assert_nil             mappings.to_hash[:mytype][:properties][:foo_object][:fields]
 
-      should "define multi_field properties" do
+        assert_equal 'nested', mappings.to_hash[:mytype][:properties][:foo_nested][:type]
+        assert_equal 'string', mappings.to_hash[:mytype][:properties][:foo_nested][:properties][:bar][:type]
+        assert_nil             mappings.to_hash[:mytype][:properties][:foo_nested][:fields]
       end
     end
 
@@ -106,8 +149,8 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
       end
 
       should "update and return the index mappings" do
-        DummyIndexingModel.mappings foo: 'boo' do; end
-        DummyIndexingModel.mappings bar: 'bam' do; end
+        DummyIndexingModel.mappings foo: 'boo'
+        DummyIndexingModel.mappings bar: 'bam'
         assert_equal( { dummy_indexing_model: { foo: "boo", bar: "bam", properties: {} } },
                       DummyIndexingModel.mappings.to_hash )
       end
@@ -371,6 +414,55 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
       end
     end
 
+    context "Checking for index existence" do
+      context "the index exists" do
+        should "return true" do
+          indices = mock('indices', exists: true)
+          client  = stub('client', indices: indices)
+
+          DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
+
+          assert_equal true, DummyIndexingModelForRecreate.index_exists?
+        end
+      end
+
+      context "the index does not exists" do
+        should "return false" do
+          indices = mock('indices', exists: false)
+          client  = stub('client', indices: indices)
+
+          DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
+
+          assert_equal false, DummyIndexingModelForRecreate.index_exists?
+        end
+      end
+
+      context "the indices raises" do
+        should "return false" do
+          client  = stub('client')
+          client.expects(:indices).raises(StandardError)
+
+          DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
+
+          assert_equal false, DummyIndexingModelForRecreate.index_exists?
+        end
+      end
+
+      context "the indices raises" do
+        should "return false" do
+          indices = stub('indices')
+          client  = stub('client')
+          client.expects(:indices).returns(indices)
+
+          indices.expects(:exists).raises(StandardError)
+
+          DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
+
+          assert_equal false, DummyIndexingModelForRecreate.index_exists?
+        end
+      end
+    end
+
     context "Re-creating the index" do
       class ::DummyIndexingModelForRecreate
         extend ActiveModel::Naming
@@ -425,8 +517,6 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         indices = stub('indices')
         client.stubs(:indices).returns(indices)
 
-        indices.expects(:exists).returns(false)
-
         indices.expects(:create).with do |payload|
           assert_equal 'dummy_indexing_model_for_recreates', payload[:index]
           assert_equal 1,         payload[:body][:settings][:index][:number_of_shards]
@@ -434,6 +524,7 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
           true
         end.returns({})
 
+        DummyIndexingModelForRecreate.expects(:index_exists?).returns(false)
         DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
 
         assert_nothing_raised { DummyIndexingModelForRecreate.create_index! }
@@ -444,11 +535,10 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         indices = stub('indices')
         client.stubs(:indices).returns(indices)
 
-        indices.expects(:exists).returns(true)
-
         indices.expects(:create).never
 
-        DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
+        DummyIndexingModelForRecreate.expects(:index_exists?).returns(true)
+        DummyIndexingModelForRecreate.expects(:client).returns(client).never
 
         assert_nothing_raised { DummyIndexingModelForRecreate.create_index! }
       end
@@ -459,9 +549,9 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         client.stubs(:indices).returns(indices)
 
         indices.expects(:delete).returns({})
-        indices.expects(:exists).returns(false)
-        indices.expects(:create).raises(Exception)
+        indices.expects(:create).raises(Exception).at_least_once
 
+        DummyIndexingModelForRecreate.expects(:index_exists?).returns(false)
         DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
 
         assert_raise(Exception) { DummyIndexingModelForRecreate.create_index! force: true }
@@ -473,9 +563,9 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         client.stubs(:indices).returns(indices)
 
         indices.expects(:delete).returns({})
-        indices.expects(:exists).returns(false)
         indices.expects(:create).returns({}).at_least_once
 
+        DummyIndexingModelForRecreate.expects(:index_exists?).returns(false)
         DummyIndexingModelForRecreate.expects(:client).returns(client).at_least_once
 
         assert_nothing_raised do
@@ -516,12 +606,11 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         end
 
         should "create the custom index" do
-          @indices.expects(:exists).with do |arguments|
+          @indices.expects(:create).with do |arguments|
             assert_equal 'custom-foo', arguments[:index]
             true
           end
-
-          @indices.expects(:create).with do |arguments|
+          DummyIndexingModelForRecreate.expects(:index_exists?).with do |arguments|
             assert_equal 'custom-foo', arguments[:index]
             true
           end