elastic_record 4.1.8 → 5.1.0

data/test/elastic_record/aggregation_response/bucket_test.rb

@@ -0,0 +1,8 @@
+require 'helper'
+
+class ElasticRecord::AggregationResponse::BucketTest < MiniTest::Test
+  def test_inspect
+    bucket = ElasticRecord::AggregationResponse::Bucket.new('key' => 'Seattle', 'count' => 12)
+    assert_equal '#<ElasticRecord::AggregationResponse::Bucket {"key"=>"Seattle", "count"=>12}>', bucket.inspect
+  end
+end

data/test/elastic_record/aggregation_response/multi_bucket_aggregation_test.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class ElasticRecord::AggregationResponse::MultiBucketAggregationTest < MiniTest::Test
+  def test_single
+    agg = ElasticRecord::AggregationResponse::MultiBucketAggregation.new 'states', {
+      "buckets" => [
+        {
+          "key" => "WA",
+          "doc_count" => 4,
+          "lterms#sales_per_month" => {
+            "buckets" => [
+              {
+                "key_as_string" => "2015-02-01",
+                "key" => 1422748800000,
+                "doc_count" => 3
+              },
+              {
+                "key_as_string" => "2015-03-01",
+                "key" => 1425168000000,
+                "doc_count" => 1
+              }
+            ]
+          }
+        }
+      ]
+    }
+
+    bucket = agg.buckets.first
+    assert_equal 4, bucket.doc_count
+    assert_equal ['sales_per_month'], bucket.aggregations.keys
+    assert_equal 2, bucket.aggregations['sales_per_month'].buckets.size
+  end
+end

data/test/elastic_record/aggregation_response/single_bucket_aggregation_test.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+class ElasticRecord::AggregationResponse::SingleBucketAggregationTest < MiniTest::Test
+  def test_single
+    agg = ElasticRecord::AggregationResponse::SingleBucketAggregation.new 'resellers', {
+      'doc_count' => 0,
+      'min#min_price' => {
+        'value' => 350
+      }
+    }
+
+    assert_equal 0, agg.doc_count
+    assert_equal 350, agg.aggregations['min_price'].value
+  end
+end

data/test/elastic_record/as_document_test.rb

@@ -2,64 +2,90 @@ require 'helper'
 
 class ElasticRecord::AsDocumentTest < MiniTest::Test
   def test_as_search_document
-    Widget.new(id: '10', color: 'green').tap do |widget|
+    Widget.new(color: 'green').tap do |widget|
       assert_equal({"color" => "green"}, widget.as_search_document)
     end
 
-    Widget.new(id: '10', color: '').tap do |widget|
+    Widget.new(color: '').tap do |widget|
       assert_equal({}, widget.as_search_document)
     end
-
-    Widget.new(id: '10', color: false).tap do |widget|
-      assert_equal({"color" => false}, widget.as_search_document)
-    end
   end
 
-  def test_as_dirty_search
-    Widget.new(id: '10', color: 'green').tap do |widget|
-      assert_equal({'color' => 'green'}, widget.as_partial_update_document)
-    end
+  def test_as_partial_update_document
+    widget = Widget.create(name: 'elmo', color: 'green')
 
-    Widget.new(id: '10').tap do |widget|
-      assert_equal({}, widget.as_partial_update_document)
-    end
+    Widget.elastic_index.update_document widget.id, name: 'wilbur'
 
-    Widget.new(id: '10', color: '').tap do |widget|
-      assert_equal({'color' => nil}, widget.as_partial_update_document)
-    end
+    widget.update! color: 'grey', widget_part: { name: 'Doohicky' }
+
+    assert_equal 1, Widget.elastic_search.filter(color: 'grey').count
+    assert_equal 1, Widget.elastic_search.filter('widget_part.name' => 'Doohicky').count
+    assert_equal 0, Widget.elastic_search.filter(name: 'elmo').count
   end
 
   class SpecialFieldsModel
     include TestModel
+    attr_accessor :meta, :book_length
 
     class Author
-      def as_search_document
-        {name: 'Jonny'}
-      end
+      include TestModel
+      attr_accessor :name, :salary_estimate
     end
 
-    self.doctype.mapping[:properties].update(
-      author: {
-        type: :object
+    self.elastic_index.mapping[:properties].update(
+      author:      {
+        type: :object,
+        properties: {
+          name: { type: :string },
+          salary_estimate: { type: :integer_range }
+        }
+      },
+      commenters:  {
+        type: :nested,
+        properties: {
+          name: { type: :string }
+        }
       },
-      commenters: {
-        type: :nested
-      }
+      meta:        { type: "object" },
+      book_length: { type: :integer_range }
     )
 
     def author
-      Author.new
+      Author.new(name: 'Jonny', salary_estimate: 250..Float::INFINITY)
     end
 
     def commenters
-      [Author.new, Author.new]
+      [Author.new(name: 'Jonny'), Author.new(name: 'Jonny')]
     end
   end
 
   def test_as_search_document_with_special_fields
-    doc = SpecialFieldsModel.new.as_search_document
+    record = SpecialFieldsModel.new(meta: { some: "value" })
 
-    assert_equal({name: 'Jonny'}, doc[:author])
+    doc = record.as_search_document
+
+    assert_equal({name: 'Jonny', salary_estimate: { 'gte' => 250, 'lte' => nil }}, doc[:author])
     assert_equal([{name: 'Jonny'}, {name: 'Jonny'}], doc[:commenters])
+    assert_equal({some: 'value'}, doc[:meta])
+  end
+
+  def test_as_search_document_with_range_fields
+    record = SpecialFieldsModel.new(book_length: 250..500)
+    doc = record.as_search_document
+    assert_equal({ "gte" => 250, "lte" => 500 }, doc[:book_length])
+
+    record = SpecialFieldsModel.new(book_length: -Float::INFINITY..500)
+    doc = record.as_search_document
+    assert_equal({ "gte" => nil, "lte" => 500 }, doc[:book_length])
+
+    record = SpecialFieldsModel.new(book_length: 250..Float::INFINITY)
+    doc = record.as_search_document
+    assert_equal({ "gte" => 250, "lte" => nil }, doc[:book_length])
+  end
+
+  def test_as_search_document_with_invalid_range_fields
+    record = SpecialFieldsModel.new(book_length: 500..250)
+    invalid_elasticsearch_doc = record.as_search_document
+    assert_equal({ "gte" => 500, "lte" => 250 }, invalid_elasticsearch_doc[:book_length])
   end
 end

data/test/elastic_record/callbacks_test.rb

@@ -2,8 +2,7 @@ require 'helper'
 
 class ElasticRecord::CallbacksTest < MiniTest::Test
   def test_added_to_index
-    widget = Widget.new id: '10', color: 'green'
-    refute Widget.elastic_index.record_exists?(widget.id)
+    widget = Widget.new color: 'green'
 
     widget.save
 
@@ -11,22 +10,19 @@ class ElasticRecord::CallbacksTest < MiniTest::Test
   end
 
   def test_not_added_to_index_if_not_dirty
-    widget = Widget.new id: '10', color: 'green'
-    widget.changed_attributes.clear
+    widget = Widget.create color: 'green'
 
-    widget.save
+    widget.elastic_index.delete_document(widget.id)
 
-    refute Widget.elastic_index.record_exists?(widget.id)
+    widget.save
+    assert_equal 0, Widget.elastic_search.count
   end
 
   def test_deleted_from_index
-    widget = Widget.new id: '10', color: 'green'
-    Widget.elastic_index.index_document(widget.id, widget.as_search_document)
-
+    widget = Widget.create color: 'green'
     assert Widget.elastic_index.record_exists?(widget.id)
 
     widget.destroy
-
     refute Widget.elastic_index.record_exists?(widget.id)
   end
 
@@ -35,7 +31,7 @@ class ElasticRecord::CallbacksTest < MiniTest::Test
 
     define_attributes [:height]
 
-    self.doctype.mapping[:properties].update(
+    self.elastic_index.mapping[:properties].update(
       height: {
         type: 'keyword'
       }

data/test/elastic_record/connection_test.rb

@@ -1,14 +1,6 @@
 require 'helper'
 
 class ElasticRecord::ConnectionTest < MiniTest::Test
-  def setup
-    ElasticRecord::JSON.parser = :active_support
-  end
-
-  def teardown
-    ElasticRecord::JSON.parser = :active_support
-  end
-
   def test_servers
     assert_equal ['foo'], ElasticRecord::Connection.new('foo').servers
     assert_equal ['foo', 'bar'], ElasticRecord::Connection.new(['foo', 'bar']).servers
@@ -30,7 +22,7 @@ class ElasticRecord::ConnectionTest < MiniTest::Test
 
   def test_json_requests
     expected = {'foo' => 'bar'}
-    stub_es_request(:any, "/test").to_return(status: 200, body: ElasticRecord::JSON.encode(expected))
+    stub_es_request(:any, "/test").to_return(status: 200, body: JSON.generate(expected))
 
     assert_equal expected, connection.json_delete("/test")
     assert_equal expected, connection.json_get("/test")
@@ -38,14 +30,9 @@ class ElasticRecord::ConnectionTest < MiniTest::Test
     assert_equal expected, connection.json_put("/test")
   end
 
-  def test_json_requests_with_oj
-    ElasticRecord::JSON.parser = :oj
-    test_json_requests
-  end
-
   def test_json_request_with_valid_error_status
     response_json = {'error' => 'Doing it wrong'}
-    stub_es_request(:get, "/error").to_return(status: 404, body: ElasticRecord::JSON.encode(response_json))
+    stub_es_request(:get, "/error").to_return(status: 404, body: JSON.generate(response_json))
 
     error = assert_raises ElasticRecord::ConnectionError do
       connection.json_get("/error")
@@ -57,7 +44,7 @@ class ElasticRecord::ConnectionTest < MiniTest::Test
   def test_retry_server_exceptions
     responses = [
       {exception: Errno::ECONNREFUSED},
-      {status: ["200", "OK"], body: ElasticRecord::JSON.encode('hello' => 'world')}
+      {status: ["200", "OK"], body: JSON.generate('hello' => 'world')}
     ]
 
     ElasticRecord::Connection.new(ElasticRecord::Config.servers, retries: 0).tap do |connection|

data/test/elastic_record/index/documents_test.rb

@@ -49,7 +49,7 @@ class ElasticRecord::Index::DocumentsTest < MiniTest::Test
     index.update_document('abc', color: 'blue')
 
     expected = {'warehouse_id' => '5', 'color' => 'blue'}
-    assert_equal expected, index.get('abc', Widget.doctype)['_source']
+    assert_equal expected, index.get('abc', index.mapping_type)['_source']
 
     assert_raises RuntimeError do
       index.update_document(nil, color: 'blue')
@@ -88,17 +88,31 @@ class ElasticRecord::Index::DocumentsTest < MiniTest::Test
     assert_equal 1, scroll_enumerator.request_more_ids.size
   end
 
-  def test_bulk_add
-    record = Widget.new(id: 'abc', color: 'red')
-
-    index.bulk_add [record]
+  def test_expired_scroll_error
+    index.index_document('bob', name: 'bob')
+    index.index_document('bobs', name: 'bob')
+
+    scroll_enumerator = index.build_scroll_enumerator(
+      search: { 'query' => { query_string: { query: 'name:bob' } } },
+      batch_size: 1,
+      keep_alive: '1ms'
+    )
+
+    scroll_enumerator.request_more_hits
+    index.connection.json_delete '/_search/scroll', scroll_id: scroll_enumerator.scroll_id
+    assert_raises ElasticRecord::ExpiredScrollError do
+      scroll_enumerator.request_more_hits
+    end
+  end
 
-    assert index.record_exists?('abc')
-    refute index.record_exists?('xyz')
+  def test_invalid_scroll_error
+    assert_raises ElasticRecord::InvalidScrollError do
+      index.scroll('invalid', '1m')
+    end
   end
 
   def test_bulk
-    assert_nil index.instance_variable_get(:@_batch)
+    assert_nil index.current_bulk_batch
 
     index.bulk do
       index.index_document '5', color: 'green'
@@ -108,9 +122,9 @@ class ElasticRecord::Index::DocumentsTest < MiniTest::Test
       expected = [
         {index: {_index: index.alias_name, _type: "widget", _id: "5"}},
         {color: "green"},
-        {update: {_index: "widgets", _type: "widget", _id: "5", _retry_on_conflict: 3}},
+        {update: {_index: "widgets", _type: "widget", _id: "5", retry_on_conflict: 3}},
         {doc: {color: "blue"}, doc_as_upsert: true},
-        {delete: {_index: index.alias_name, _type: "widget", _id: "3", _retry_on_conflict: 3}}
+        {delete: {_index: index.alias_name, _type: "widget", _id: "3", retry_on_conflict: 3}}
       ]
       assert_equal expected, index.current_bulk_batch
     end
@@ -118,6 +132,37 @@ class ElasticRecord::Index::DocumentsTest < MiniTest::Test
     assert_nil index.current_bulk_batch
   end
 
+  def test_bulk_nested
+    expected_warehouse_count = Warehouse.count + 2
+
+    Warehouse.elastic_index.bulk do
+      Warehouse.elastic_index.bulk do
+        Warehouse.create(name: 'Warehouse 13')
+      end
+      Warehouse.create(name: 'Warehouse 12')
+    end
+
+    assert_equal 2, Warehouse.elastic_relation.count
+    assert_equal expected_warehouse_count, Warehouse.count
+  end
+
+  def test_bulk_nested_with_error
+    expected_warehouse_count = Warehouse.count
+
+    begin
+      Warehouse.elastic_index.bulk do
+        Warehouse.elastic_index.bulk do
+          Warehouse.create(name: 'Warehouse 13')
+        end
+
+        Warehouse.create(name: nil)
+      end
+    rescue ActiveRecord::NotNullViolation
+    end
+
+    assert_equal 0, Warehouse.elastic_relation.count
+  end
+
   def test_bulk_error
     without_deferring(index) do
       begin
@@ -133,7 +178,7 @@ class ElasticRecord::Index::DocumentsTest < MiniTest::Test
     end
   end
 
-  def test_bulk_inheritence
+  def test_bulk_inheritance
     without_deferring(index) do
       index.bulk do
         InheritedWidget.elastic_index.index_document '5', color: 'green'

data/test/elastic_record/index/manage_test.rb

@@ -25,13 +25,6 @@ class ElasticRecord::Index::ManageTest < MiniTest::Test
     assert !index.exists?('felons_bar')
   end
 
-  def test_type_exists
-    index.create 'felons_foo'
-
-    assert index.type_exists?('felons_foo')
-    assert !index.type_exists?('felons_bar')
-  end
-
   def test_deploy
     index.create 'felons_foo'
 

data/test/elastic_record/index/mapping_test.rb

@@ -4,14 +4,23 @@ class ElasticRecord::Index::MappingTest < MiniTest::Test
   def test_get_mapping
     expected = {
       "widget" => {
-        "_all" => { "enabled" => false },
         "properties" => {
           "color" => { "type" => "keyword" },
           "name" => {
-            "type" => "keyword",
-            "fields" => { "analyzed" => { "type" => "text" } }
+            "type" => "text",
+            "fields" => {
+              "raw" => { "type" => "keyword" }
+            }
           },
-          "warehouse_id" => { "type" => "keyword" }
+          "price" => {
+            "type" => "long"
+          },
+          "warehouse_id" => { "type" => "keyword" },
+          "widget_part" => {
+            "properties" => {
+              "name" => { "type" => "keyword" }
+            }
+          }
         }
       }
     }
@@ -19,9 +28,13 @@ class ElasticRecord::Index::MappingTest < MiniTest::Test
     assert_equal expected, index.get_mapping
   end
 
+  def test_update_mapping
+    index.update_mapping
+  end
+
   private
 
     def index
-      @index ||= ElasticRecord::Index.new(Widget)
+      @index ||= Widget.elastic_index
     end
 end

data/test/elastic_record/index/settings_test.rb

@@ -9,7 +9,7 @@ class ElasticRecord::Index::SettingsTest < MiniTest::Test
   class ModelWithAnalyzers
     include TestModel
 
-    doctype.analysis = {
+    elastic_index.analysis = {
       "analyzer": {
         "my_custom_analyzer": {
           "type":      "custom",
@@ -38,10 +38,4 @@ class ElasticRecord::Index::SettingsTest < MiniTest::Test
 
     assert_equal expected, ModelWithAnalyzers.elastic_index.settings
   end
-
-  private
-
-    def index
-      @index ||= ElasticRecord::Index.new(Widget)
-    end
 end