elastic_record 4.1.8 → 5.1.0

data/test/elastic_record/index_test.rb

@@ -7,10 +7,6 @@ class ElasticRecord::IndexTest < MiniTest::Test
     refute_equal copied.settings.object_id, index.settings.object_id
   end
 
-  def test_doctypes
-    assert_equal [Widget.doctype], index.doctypes
-  end
-
   def test_alias_name
     assert_equal 'widgets', index.alias_name
   end

data/test/elastic_record/integration/active_record_test.rb

@@ -2,20 +2,17 @@ require 'helper'
 
 class ElasticRecord::ActiveRecordTest < MiniTest::Test
   def test_ordering
-    poo_product = Project.create! name: "Poo"
-    bear_product = Project.create! name: "Bear"
-    Project.elastic_index.refresh
+    poo_product = Warehouse.create! name: "Poo"
+    bear_product = Warehouse.create! name: "Bear"
 
-    assert_equal [bear_product, poo_product], Project.elastic_relation.order(name: 'asc')
-    assert_equal [poo_product, bear_product], Project.elastic_relation.order(name: 'desc')
+    assert_equal [bear_product, poo_product], Warehouse.elastic_relation.order(name: 'asc')
+    assert_equal [poo_product, bear_product], Warehouse.elastic_relation.order(name: 'desc')
   end
 
   def test_update_callback
-    project = Project.create! name: "Ideas"
-    Project.elastic_index.refresh
+    project = Warehouse.create! name: "Ideas"
     project.update! name: 'Terrible Stuff'
-    Project.elastic_index.refresh
 
-    assert_equal [project], Project.elastic_relation.filter(name: 'Terrible Stuff')
+    assert_equal [project], Warehouse.elastic_relation.filter(name: 'Terrible Stuff')
   end
 end

data/test/elastic_record/model_test.rb

@@ -17,8 +17,11 @@ class ElasticRecord::ModelTest < MiniTest::Test
     assert_equal Widget, index.model
   end
 
-  def test_elastic_index_inheritence
+  def test_elastic_index_inheritance
     refute_equal Widget.elastic_index.object_id, InheritedModel.elastic_index.object_id
-    refute_equal Widget.doctype.object_id, InheritedModel.doctype.object_id
+    assert_equal Widget.elastic_index.mapping_type, InheritedModel.elastic_index.mapping_type
+    assert_equal 'widgets', InheritedModel.elastic_index.alias_name
+    assert_equal InheritedModel, InheritedModel.elastic_index.model
+    assert_equal 'widget', InheritedModel.elastic_index.mapping_type
   end
 end

data/test/elastic_record/percolator_model_test.rb

@@ -2,15 +2,35 @@ require 'helper'
 
 class ElasticRecord::PercolatorModelTest < MiniTest::Test
   def test_elastic_index
-    assert_equal [WidgetQuery.doctype, Widget.doctype], index.doctypes
+    index = WidgetQuery.elastic_index
+
+    expected_mapping = {
+      "widget"=> {
+        "properties"=> {
+          "color"=> {"type" => "keyword" },
+          "name"=> {
+            "type" => "text",
+            "fields" => {
+              "raw" => { "type" => "keyword" }
+            }
+          },
+          "price" => { "type" => "long" },
+          "query" => { "type" => "percolator" },
+          "warehouse_id" => { "type" => "keyword" },
+          "widget_part" => {
+            "properties" => {
+              "name" => { "type" => "keyword" }
+            }
+          }
+        }
+      }
+    }
+
+    assert_equal expected_mapping, index.get_mapping
     refute index.partial_updates
     assert_equal({}, index.settings)
   end
 
-  def test_doctype
-    assert_equal ElasticRecord::Doctype.percolator_doctype, WidgetQuery.doctype
-  end
-
   def test_as_search_document
     query = WidgetQuery.new(name: 'foo', color: 'red')
 
@@ -45,10 +65,4 @@ class ElasticRecord::PercolatorModelTest < MiniTest::Test
 
     assert_equal [query], WidgetQuery.percolate(should_hit)
   end
-
-  private
-
-    def index
-      @index ||= WidgetQuery.elastic_index
-    end
 end

data/test/elastic_record/relation/batches_test.rb

@@ -3,79 +3,61 @@ require 'helper'
 class ElasticRecord::Relation::BatchesTest < MiniTest::Test
   def setup
     super
-    create_widgets
+    @red_widget   = Widget.create!(color: 'red')
+    @blue_widget  = Widget.create!(color: 'blue')
+    @green_widget = Widget.create!(color: 'green')
   end
 
-  def test_find_each
-    results = []
-    Widget.elastic_relation.find_each do |widget|
-      results << widget.id
-    end
-    assert_equal ['5', '10', '15'].to_set, results.to_set
-  end
+  # def test_find_each
+  #   results = []
+  #   Widget.elastic_relation.find_each do |widget|
+  #     results << widget
+  #   end
+  #   assert_equal [@red_widget, @blue_widget, @green_widget].to_set, results.to_set
+  # end
 
   def test_find_ids_in_batches
     results = []
     Widget.elastic_relation.find_ids_in_batches do |ids|
       results << ids
     end
-    assert_equal [['5', '10', '15'].to_set], results.map(&:to_set)
+    assert_equal [[@red_widget.id.to_s, @blue_widget.id.to_s, @green_widget.id.to_s].to_set], results.map(&:to_set)
   end
 
-  def test_find_ids_in_batches_with_order
+  def test_find_in_batches
     results = []
-    Widget.elastic_relation.order(color: :asc).find_ids_in_batches do |ids|
-      results << ids
+    Widget.elastic_relation.find_in_batches do |widgets|
+      results << widgets
     end
-
-    assert_equal [['10', '15', '5']], results
+    assert_equal [[@red_widget, @blue_widget, @green_widget].to_set], results.map(&:to_set)
   end
 
-  def test_find_ids_in_batches_with_size
+  def test_find_in_batches_with_order
     results = []
-    Widget.elastic_relation.find_ids_in_batches(batch_size: 2) do |ids|
-      results << ids
+    Widget.elastic_relation.order(color: :asc).find_in_batches do |records|
+      results << records
     end
 
-    assert_equal 2, results.size
-    assert_equal 2, results[0].size
-    assert_equal 1, results[1].size
-    assert_equal ['5', '10', '15'].to_set, results.flatten.to_set
+    assert_equal [[@blue_widget, @green_widget, @red_widget]], results
   end
 
-  def test_find_in_batches
+  def test_find_in_batches_with_size
     results = []
-    Widget.elastic_relation.find_in_batches do |widgets|
-      results << widgets.map(&:id)
+    Widget.elastic_relation.find_in_batches(batch_size: 2) do |records|
+      results << records
     end
-    assert_equal [['5', '10', '15'].to_set], results.map(&:to_set)
+
+    assert_equal 2, results.size
+    assert_equal 2, results[0].size
+    assert_equal 1, results[1].size
+    assert_equal [@red_widget, @blue_widget, @green_widget].to_set, results.flatten.to_set
   end
 
   def test_find_in_batches_with_scope
     results = []
     Widget.elastic_relation.filter(color: %w(red blue)).find_in_batches do |widgets|
-      results << widgets.map(&:id)
-    end
-    assert_equal [['5', '10'].to_set], results.map(&:to_set)
-  end
-
-  def test_find_with_batch_size
-    results = []
-    Widget.elastic_relation.find_ids_in_batches(batch_size: 1) do |ids|
-      results << ids
+      results << widgets
     end
-
-    assert_equal 3, results.size
-    results.each { |r| assert_equal 1, r.size }
-    assert_equal ['5', '10', '15'].to_set, results.flatten.to_set
+    assert_equal [[@red_widget, @blue_widget].to_set], results.map(&:to_set)
   end
-
-  private
-    def create_widgets
-      Widget.elastic_index.bulk_add [
-        Widget.new(id: 5, color: 'red'),
-        Widget.new(id: 10, color: 'blue'),
-        Widget.new(id: 15, color: 'green')
-      ]
-    end
 end

data/test/elastic_record/relation/delegation_test.rb

@@ -2,7 +2,7 @@ require 'helper'
 
 class ElasticRecord::Relation::DelegationTest < MiniTest::Test
   def test_delegate_to_array
-    Widget.elastic_index.index_document('5', color: 'red')
+    Widget.create! color: 'red'
 
     records = []
     Widget.elastic_relation.each do |record|

data/test/elastic_record/relation/finder_methods_test.rb

@@ -3,23 +3,23 @@ require 'helper'
 class ElasticRecord::Relation::FinderMethodsTest < MiniTest::Test
   def setup
     super
-    create_widgets
+    @red_widget = Widget.create(color: 'red')
+    @blue_widget = Widget.create(color: 'blue')
   end
 
   def test_find
-    refute_nil Widget.elastic_relation.find('05')
-    refute_nil Widget.elastic_relation.filter('color' => 'red').find('05')
+    refute_nil Widget.elastic_relation.find(@red_widget.id)
+    refute_nil Widget.elastic_relation.filter('color' => 'red').find(@red_widget.id)
 
     assert_raises ActiveRecord::RecordNotFound do
-      Widget.elastic_relation.filter('color' => 'blue').find('05')
+      Widget.elastic_relation.filter('color' => 'blue').find(@red_widget.id)
     end
   end
 
   def test_find_passed_an_array
-    assert_equal 2, Widget.elastic_relation.find(['05', '10']).size
-    assert_equal 2, Widget.elastic_relation.filter('color' => ['red', 'blue']).find(['05', '10']).size
-    assert_equal 0, Widget.elastic_relation.find(['15', '20']).size
-    assert_equal 0, Widget.elastic_relation.filter('color' => ['purple', 'gold']).find(['05', '10']).size
+    assert_equal 2, Widget.elastic_relation.find([@red_widget.id, @blue_widget.id]).size
+    assert_equal 2, Widget.elastic_relation.filter('color' => ['red', 'blue']).find([@red_widget.id, @blue_widget.id]).size
+    assert_equal 0, Widget.elastic_relation.filter('color' => ['purple', 'gold']).find([@red_widget.id, @blue_widget.id]).size
   end
 
   def test_find_passed_an_empty_args
@@ -29,23 +29,23 @@ class ElasticRecord::Relation::FinderMethodsTest < MiniTest::Test
   end
 
   def test_first
-    assert_equal '10', Widget.elastic_relation.order('color').first.id
-    assert_equal '05', Widget.elastic_relation.order('color').filter('color' => 'red').first.id
-    assert_equal '10', Widget.elastic_relation.order('color').filter('color' => 'blue').first.id
+    assert_equal 'blue', Widget.elastic_relation.order('color').first.color
+    assert_equal 'red', Widget.elastic_relation.order('color').filter('color' => 'red').first.color
+    assert_equal 'blue', Widget.elastic_relation.order('color').filter('color' => 'blue').first.color
     assert_nil Widget.elastic_relation.filter('color' => 'green').first
   end
 
   def test_first_with_bang
-    assert_equal '10', Widget.elastic_relation.order('color').first!.id
+    assert_equal 'blue', Widget.elastic_relation.order('color').first!.color
     assert_raises ActiveRecord::RecordNotFound do
       Widget.elastic_relation.filter('color' => 'green').first!
     end
   end
 
   def test_last
-    assert_equal '05', Widget.elastic_relation.order('color').last.id
-    assert_equal '05', Widget.elastic_relation.order('color' => 'asc').last.id
-    assert_equal '10', Widget.elastic_relation.order('color' => 'desc').last.id
+    assert_equal 'red', Widget.elastic_relation.order('color').last.color
+    assert_equal 'red', Widget.elastic_relation.order('color' => 'asc').last.color
+    assert_equal 'blue', Widget.elastic_relation.order('color' => 'desc').last.color
   end
 
   def test_all
@@ -54,24 +54,10 @@ class ElasticRecord::Relation::FinderMethodsTest < MiniTest::Test
   end
 
   def test_find_by
-    Widget.elastic_index.bulk_add [
-      Widget.new(color: 'red', id: '05'),
-      Widget.new(color: 'blue', id: '10'),
-    ]
-
-    assert_equal '05', Widget.elastic_relation.find_by(color: 'red').id
-    assert_equal '05', Widget.elastic_relation.find_by!(color: 'red').id
+    assert_equal 'red', Widget.elastic_relation.find_by(color: 'red').color
+    assert_equal 'red', Widget.elastic_relation.find_by!(color: 'red').color
     assert_raises ActiveRecord::RecordNotFound do
       Widget.elastic_relation.find_by!(color: 'green')
     end
   end
-
-  private
-
-    def create_widgets
-      Widget.elastic_index.bulk_add [
-        Widget.new(color: 'red', id: '05'),
-        Widget.new(color: 'blue', id: '10'),
-      ]
-    end
 end

data/test/elastic_record/relation/hits_test.rb

@@ -0,0 +1,49 @@
+require 'helper'
+
+class ElasticRecord::Relation::HitsTest < MiniTest::Test
+  def test_to_ids
+    red_widget = Widget.create(color: 'red')
+    blue_widget = Widget.create(color: 'red')
+
+    assert_equal [red_widget.id.to_s, blue_widget.id.to_s].to_set, Widget.elastic_relation.to_ids.to_set
+  end
+
+  def test_to_a
+    red_widget = Widget.create(color: 'red')
+    blue_widget = Widget.create(color: 'red')
+
+    array = Widget.elastic_relation.to_a
+
+    assert_equal 2, array.size
+    assert array.first.is_a?(Widget)
+  end
+
+  def test_to_a_from_source
+    warehouses = [Project.new(name: 'Latte'), Project.new(name: 'Americano')]
+    result = Project.elastic_index.bulk_add(warehouses)
+
+    array = Project.elastic_relation.to_a
+
+    assert_equal 2, array.size
+    assert array.first.is_a?(Project)
+    names = array.map(&:name)
+    assert_includes names, 'Latte'
+    assert_includes names, 'Americano'
+  end
+
+  def test_search_hits
+    coffees = [Project.new(name: 'Latte'), Project.new(name: 'Americano')]
+    Project.elastic_index.bulk_add(coffees)
+
+    array = Project.elastic_relation.search_hits
+    assert_equal %w(Latte Americano).to_set, array.map { |hit| hit["_source"]["name"] }.to_set
+  end
+
+  def test_search_results
+    coffees = [Project.new(name: 'Latte'), Project.new(name: 'Americano')]
+    Project.elastic_index.bulk_add(coffees)
+
+    results = Project.elastic_relation.search_results
+    %w(took timed_out _shards hits).each { |key| assert results.key?(key) }
+  end
+end

data/test/elastic_record/relation/search_methods_test.rb

@@ -198,29 +198,33 @@ class ElasticRecord::Relation::SearchMethodsTest < MiniTest::Test
   end
 
   def test_select
-    selectable_klass = Widget.anon do
-      def self.select(values)
-        @latest_select = values
-        self
-      end
-    end
+    scope = relation.select 'foo'
 
-    relation = selectable_klass.elastic_relation.select 'foo'
-    relation.to_a
-
-    assert_equal ['foo'], selectable_klass.instance_variable_get('@latest_select')
+    assert_equal ['foo'], scope.select_values
   end
 
   def test_select_with_block
-    Widget.elastic_index.bulk_add [
-      Widget.new(id: 5, color: 'red'),
-      Widget.new(id: 10, color: 'blue')
-    ]
+    red_widget = Widget.create(color: 'red')
+    blue_widget = Widget.create(color: 'blue')
 
-    records = relation.select { |record| record.id == '10' }
+    records = relation.select { |record| record.id == blue_widget.id }
 
     assert_equal 1, records.size
-    assert_equal '10', records.first.id
+    assert_equal blue_widget, records.first
+  end
+
+  def test_includes
+    warehouse = Warehouse.create! name: 'Boeing'
+    widget = Widget.create! name: '747', color: 'red', warehouse: warehouse
+    widget = Widget.create! name: '747', color: 'green', warehouse: warehouse
+
+    widgets = relation.filter(color: 'red').includes(:warehouse)
+    assert_equal 1, widgets.count
+    assert widgets.first.association(:warehouse).loaded?
+
+    widgets = relation.filter(color: 'red')
+    assert_equal 1, widgets.count
+    refute widgets.first.association(:warehouse).loaded?
   end
 
   def test_extending_with_block

data/test/elastic_record/relation_test.rb

@@ -3,73 +3,47 @@ require 'helper'
 class ElasticRecord::RelationTest < MiniTest::Test
   def test_count
     original_count = Widget.elastic_relation.count
-    create_widgets [Widget.new(id: 5, color: 'red'), Widget.new(id: 10, color: 'blue')]
+    Widget.create(color: 'red')
+    Widget.create(color: 'blue')
 
     assert_equal 2, Widget.elastic_relation.count - original_count
   end
 
   def test_aggregations
-    create_widgets [Widget.new(id: 5, color: 'red'), Widget.new(id: 10, color: 'blue')]
+    Widget.create(color: 'red', price: 5)
+    Widget.create(color: 'blue', price: 10)
 
     aggregations = Widget.elastic_relation.aggregate('popular_colors' => {'terms' => {'field' => 'color'}}).aggregations
 
-    assert_equal 2, aggregations['popular_colors']['buckets'].size
-    assert_equal %w(red blue).to_set, aggregations['popular_colors']['buckets'].map { |bucket| bucket['key'] }.to_set
+    assert_equal 2, aggregations['popular_colors'].buckets.size
+    assert_equal %w(red blue).to_set, aggregations['popular_colors'].buckets.map(&:key).to_set
+
+    aggregations = Widget.elastic_relation.aggregate('avg_price' => {'avg' => {'field' => 'price'}}).aggregations
+    assert_equal 7.5, aggregations['avg_price'].value
   end
 
   def test_explain
-    create_widgets [Widget.new(id: 10, color: 'blue')]
+    Widget.create(color: 'blue')
 
     # explain = Widget.elastic_relation.filter(color: 'blue').explain('10')
   end
 
-  def test_to_hits
-    # assert Widget.elastic_relation.search_results.is_a?(ElasticSearch::Api::Hits)
-  end
-
-  def test_to_ids
-    create_widgets [Widget.new(id: 5, color: 'red'), Widget.new(id: 10, color: 'blue')]
-
-    assert_equal ['5', '10'].to_set, Widget.elastic_relation.to_ids.to_set
-  end
-
-  def test_to_a
-    create_widgets [Widget.new(id: 5, color: 'red'), Widget.new(id: 10, color: 'blue')]
-
-    array = Widget.elastic_relation.to_a
-
-    assert_equal 2, array.size
-    assert array.first.is_a?(Widget)
-  end
-
-  def test_to_a_from_source
-    warehouses = [Warehouse.new(name: 'Amazon'), Warehouse.new(name: 'Walmart')]
-    result = Warehouse.elastic_index.bulk_add(warehouses)
-
-    array = Warehouse.elastic_relation.to_a
-
-    assert_equal 2, array.size
-    assert array.first.is_a?(Warehouse)
-    names = array.map(&:name)
-    assert_includes names, 'Amazon'
-    assert_includes names, 'Walmart'
-  end
-
   def test_delete_all
-    project_red = Project.create! name: 'Red'
-    project_blue = Project.create! name: 'Blue'
+    project_red = Warehouse.create! name: 'Red'
+    project_blue = Warehouse.create! name: 'Blue'
 
-    Project.elastic_relation.filter(name: 'Red').delete_all
+    Warehouse.elastic_relation.filter(name: 'Red').delete_all
 
-    assert_nil Project.find_by(id: project_red.id)
-    assert_equal 0, Project.elastic_relation.filter(name: 'Red').count
+    assert_nil Warehouse.find_by(id: project_red.id)
+    assert_equal 0, Warehouse.elastic_relation.filter(name: 'Red').count
 
-    refute_nil Project.find_by(id: project_blue.id)
-    assert_equal 1, Project.elastic_relation.filter(name: 'Blue').count
+    refute_nil Warehouse.find_by(id: project_blue.id)
+    assert_equal 1, Warehouse.elastic_relation.filter(name: 'Blue').count
   end
 
   def test_equal
-    create_widgets [Widget.new(id: 5, color: 'red'), Widget.new(id: 10, color: 'blue')]
+    Widget.create(color: 'red')
+    Widget.create(color: 'blue')
 
     assert_equal Widget.elastic_relation.filter(color: 'red'), Widget.elastic_relation.filter(color: 'red')
     refute_equal Widget.elastic_relation.filter(color: 'red'), Widget.elastic_relation.filter(color: 'blue')
@@ -80,9 +54,4 @@ class ElasticRecord::RelationTest < MiniTest::Test
   def test_inspect
     assert_equal [].inspect, Widget.elastic_relation.filter(color: 'magenta').inspect
   end
-
-  private
-    def create_widgets(widgets)
-      Widget.elastic_index.bulk_add(widgets)
-    end
 end