elasticated 1.0.0

data/spec/aggregation_spec.rb

@@ -0,0 +1,587 @@
+require_relative 'spec_helper'
+
+module Elasticated
+
+  describe MaxAggregation do
+
+    it "should build a max aggregation over a field" do
+      agg = MaxAggregation.new :numeric_field
+      expected_result = { max: { field: :numeric_field } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a max aggregation over a field with custom params" do
+      agg = MaxAggregation.new :numeric_field, script: 'your_script'
+      expected_result = { max: { field: :numeric_field, script: 'your_script' } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should map a single value aggregated response" do
+      agg = MaxAggregation.new :numeric_field
+      response = { 'value' => 54 }
+      expect(agg.parse(response)).to eq 54
+    end
+
+  end
+
+  # sum, min, and avg aggregations are the same as max aggregation
+
+  describe CardinalityAggregation do
+
+    it "should build a cardinality aggregation over a field" do
+      agg = CardinalityAggregation.new :some_field
+      expected_result = { cardinality: { field: :some_field } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a cardinality aggregation over a field with custom params" do
+      agg = CardinalityAggregation.new :some_field, precision_threshold: 100
+      expected_result = { cardinality: { field: :some_field, precision_threshold: 100 } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should map a single value aggregated response" do
+      agg = CardinalityAggregation.new :some_field
+      response = { 'value' => 54 }
+      expect(agg.parse(response)).to eq 54
+    end
+  end
+
+  describe CountFilteredAggregation do
+
+    it "should build a filter aggregation over a field" do
+      agg = CountFilteredAggregation.new :filter_name do |f|
+        f.must{ custom my_filter: {} }
+      end
+      expected_result = { filter: { my_filter: {} } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should map a 'count filtered' aggregation response" do
+      agg = CountFilteredAggregation.new :filter_by_field do |f|
+        f.equal :field, :value
+      end
+      response = { 'doc_count' => 678 }
+      expect(agg.parse(response)).to eq 678
+    end
+
+  end
+
+  describe GroupAggregation do
+
+    it "should build a terms aggregation over a field" do
+      agg = GroupAggregation.new :user
+      expected_result = { terms: { field: :user, size: 0 } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with limited size" do
+      agg = GroupAggregation.new :user, size: 5
+      expected_result = { terms: { field: :user, size: 5 } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with some sorting" do
+      agg = GroupAggregation.new :user, order: :age
+      expected_result = { terms: { field: :user, size: 0, order: { age: :desc } } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with some sorting and method" do
+      agg = GroupAggregation.new :user, order: :age, order_method: :asc
+      expected_result = { terms: { field: :user, size: 0, order: { age: :asc } } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with some sorting hash" do
+      agg = GroupAggregation.new :user, order: { age: :desc }
+      expected_result = { terms: { field: :user, size: 0, order: { age: :desc } } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with some sorting string" do
+      agg = GroupAggregation.new :user, order: 'some_field:asc'
+      expected_result = { terms: { field: :user, size: 0, order: { 'some_field' => 'asc' } } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with a multiple sorting hash" do
+      agg = GroupAggregation.new :user, order: { age: :asc, name: :desc }
+      expected_result = { terms: { field: :user, size: 0, order: [ { age: :asc }, { name: :desc } ] } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with multiple sorting strings" do
+      agg = GroupAggregation.new :user, order: ['some_field:asc', 'name:desc']
+      expected_result = { terms: { field: :user, size: 0, order: [ { 'some_field' => 'asc' }, { 'name' => 'desc' } ] } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with multiple partial sorting strings" do
+      agg = GroupAggregation.new :user, order: ['some_field', 'name:asc']
+      expected_result = { terms: { field: :user, size: 0, order: [ { 'some_field' => :desc }, { 'name' => 'asc' } ] } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with custom params" do
+      agg = GroupAggregation.new :user, order: :age, order_method: :asc, size: 15, script: 'your_script'
+      expected_result = { terms: { field: :user, size: 15, order: { age: :asc }, script: 'your_script' } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with subaggregations" do
+      agg = GroupAggregation.new :user do |user|
+        user.max :age
+        user.sum :childs
+      end
+      expected_result = {
+        terms: { field: :user, size: 0 },
+        aggs: {
+          max_age: { max: { field: :age } },
+          sum_childs: { sum: { field: :childs } }
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+      it "should map a group aggregation response" do
+        agg = GroupAggregation.new :field
+        response = { 'buckets' => [
+          { 'key' => 'value1', 'doc_count' => 'count1' },
+          { 'key' => 'value2', 'doc_count' => 'count2' },
+          { 'key' => 'value3', 'doc_count' => 'count3' }
+        ] }
+        expect(agg.parse(response)).to eq({
+          'value1' => { 'count' => 'count1' },
+          'value2' => { 'count' => 'count2' },
+          'value3' => { 'count' => 'count3' }
+        })
+      end
+
+  end
+
+  describe CountAggregation do
+
+    it "should build a terms aggregation over a field" do
+      agg = CountAggregation.new :user
+      expected_result = { terms: { field: :user, size: 0 } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with custom params" do
+      agg = CountAggregation.new :user, script: 'your_script'
+      expected_result = { terms: { field: :user, size: 0, script: 'your_script' } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should map a 'count' aggregation response" do
+      agg = CountAggregation.new :field
+      response = { 'buckets' => [
+        { 'key' => 'value1', 'doc_count' => 'count1' },
+        { 'key' => 'value2', 'doc_count' => 'count2' },
+        { 'key' => 'value3', 'doc_count' => 'count3' }
+      ] }
+      expect(agg.parse(response)).to eq({
+        'value1' => 'count1',
+        'value2' => 'count2',
+        'value3' => 'count3'
+      })
+    end
+
+  end
+
+  describe CountDistinctAggregation do
+
+    it "should build a terms aggregation over a field" do
+      agg = CountDistinctAggregation.new :user
+      expected_result = { value_count: { field: :user } }
+      expect(agg.build).to eq expected_result
+    end
+
+  end
+
+  describe HistogramAggregation do
+
+    it "should build a histogram aggregation" do
+      agg = HistogramAggregation.new :age, 7
+      expected_result = { histogram: { field: :age, interval: 7 } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a histogram aggregation with custom params" do
+      agg = HistogramAggregation.new :age, 7, script: 'your_script'
+      expected_result = { histogram: { field: :age, interval: 7, script: 'your_script' } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a histogram aggregation with subaggregations" do
+      agg = HistogramAggregation.new :age, 7 do |user|
+        user.max :numeric_field
+        user.sum :childs
+      end
+      expected_result = {
+        histogram: { field: :age, interval: 7 },
+        aggs: {
+          max_numeric_field: { max: { field: :numeric_field } },
+          sum_childs: { sum: { field: :childs } }
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+  end
+
+  describe DateHistogramAggregation do
+
+    it "should build a date histogram aggregation" do
+      agg = DateHistogramAggregation.new :date
+      expected_result = { date_histogram: { field: :date, interval: 'day', format: 'yyyy-MM-dd' } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a date histogram aggregation with custom interval" do
+      agg = DateHistogramAggregation.new :date, interval: '7d'
+      expected_result = { date_histogram: { field: :date, interval: '7d', format: 'yyyy-MM-dd' } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a date histogram aggregation with custom format" do
+      agg = DateHistogramAggregation.new :date, interval: '7d', format: 'your_format'
+      expected_result = { date_histogram: { field: :date, interval: '7d', format: 'your_format' } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a date histogram aggregation with custom params" do
+      agg = DateHistogramAggregation.new :date, script: 'your_script'
+      expected_result = { date_histogram: { field: :date, interval: 'day', format: 'yyyy-MM-dd', script: 'your_script' } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a date histogram aggregation with subaggregations" do
+      agg = DateHistogramAggregation.new :date do |docs|
+        docs.max :numeric_field
+        docs.sum :childs
+      end
+      expected_result = {
+        date_histogram: { field: :date, interval: 'day', format: 'yyyy-MM-dd' },
+        aggs: {
+          max_numeric_field: { max: { field: :numeric_field } },
+          sum_childs: { sum: { field: :childs } }
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should map a 'date histogram' aggregation response" do
+      agg = DateHistogramAggregation.new :field
+      response = {'buckets' => [
+        { 'key_as_string' => '2014-01-01', 'doc_count' => 'count1' },
+        { 'key_as_string' => '2014-01-02', 'doc_count' => 'count2' },
+        { 'key_as_string' => '2014-01-03', 'doc_count' => 'count3' }
+      ] }
+      expect(agg.parse(response)).to eq({
+        '2014-01-01' => { 'count' => 'count1' },
+        '2014-01-02' => { 'count' => 'count2' },
+        '2014-01-03' => { 'count' => 'count3' }
+      })
+    end
+
+  end
+
+  describe FilterAggregation do
+
+    it "should build a filter aggregation" do
+      agg = FilterAggregation.new :some_name do |f|
+        f.conditions do |c|
+          c.must{ custom my_filter: {} }
+        end
+      end
+      expected_result = { filter: { my_filter: {} } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a filter aggregation with subaggregations" do
+      agg = FilterAggregation.new :some_name do |f|
+        f.conditions do |c|
+          c.must{ custom my_filter: {} }
+        end
+        f.max :age
+        f.sum :numeric_field
+      end
+      expected_result = {
+        filter: { my_filter: {} },
+        aggs: {
+          max_age: { max: { field: :age } },
+          sum_numeric_field: { sum: { field: :numeric_field } }
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+  end
+
+  describe NestedAggregation do
+
+    it "should build a nested aggregation" do
+      agg = NestedAggregation.new 'some.path'
+      expected_result = { nested: { path: 'some.path' } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a nested aggregation with an alias" do
+      agg = NestedAggregation.new 'some.path', as: :some_alias
+      expected_result = { nested: { path: 'some.path' } }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a nested aggregation" do
+      agg = NestedAggregation.new 'some.path' do |n|
+        n.max :age
+        n.sum :numeric_field
+      end
+      expected_result = {
+        nested: { path: 'some.path' },
+        aggs: {
+          max_age: { max: { field: :age } },
+          sum_numeric_field: { sum: { field: :numeric_field } }
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should map a 'nested' response" do
+      agg = NestedAggregation.new 'my_path' do |n|
+        n.group :user
+      end
+      response = {
+        'doc_count' => 5,
+        'group_by_user' => {
+          'buckets' => [ { 'key' => 'user1', 'doc_count' => 2 } ]
+        }
+      }
+      expect(agg.parse(response)).to eq({
+        'count' => 5,
+        'group_by_user' => { 'user1' => { 'count' => 2 } }
+      })
+    end
+
+  end
+
+  describe RangeAggregation do
+
+    it "should build a range aggregation" do
+      agg = RangeAggregation.new :numeric_field do |f|
+        f.ranges do |c|
+          c.less_equal 15
+          c.between 15, 20
+          c.greater_equal 20
+        end
+      end
+      expected_result = {
+        range: {
+          field: :numeric_field,
+          keyed: true,
+          ranges: [
+            { key: 'less_equal_15', to: 15 },
+            { key: 'between_15_and_20', from: 15, to: 20 },
+            { key: 'greater_equal_20', from: 20 }
+          ]
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a range aggregation with extra params" do
+      agg = RangeAggregation.new :numeric_field, script: 'your_script' do |f|
+        f.ranges do |c|
+          c.less_equal 15
+          c.between 15, 20
+          c.greater_equal 20
+        end
+      end
+      expected_result = {
+        range: {
+          field: :numeric_field,
+          keyed: true,
+          script: 'your_script',
+          ranges: [
+            { key: 'less_equal_15', to: 15 },
+            { key: 'between_15_and_20', from: 15, to: 20 },
+            { key: 'greater_equal_20', from: 20 }
+          ]
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a range aggregation with subaggregations" do
+      agg = RangeAggregation.new :numeric_field do |f|
+        f.ranges do |c|
+          c.less_equal 15
+          c.between 15, 20
+          c.greater_equal 20
+        end
+        f.max :age
+        f.sum :numeric_field
+      end
+      expected_result = {
+        range: {
+          field: :numeric_field,
+          keyed: true,
+          ranges: [
+            { key: 'less_equal_15', to: 15 },
+            { key: 'between_15_and_20', from: 15, to: 20 },
+            { key: 'greater_equal_20', from: 20 }
+          ]
+        },
+        aggs: {
+          max_age: { max: { field: :age } },
+          sum_numeric_field: { sum: { field: :numeric_field } }
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should map a 'range' response" do
+      agg = RangeAggregation.new :a_field do |a|
+        a.ranges do |r|
+          r.greater_equal :max_value, 'high_values'
+          r.less_equal :min_value
+          r.between :min_value, :max_value
+        end
+      end
+      response = {
+        'buckets' => {
+          'high_values' => {
+            'from' => 'max_value',
+            'doc_count' => 5
+          },
+          'less_equal_min_value' => {
+            'to' => 'min_value',
+            'doc_count' => 3
+          },
+          'between_min_value_and_max_value' => {
+            'from' => 'min_value',
+            'to' => 'max_value',
+            'doc_count' => 9
+          }
+        }
+      }
+      expect(agg.parse(response)).to eq({
+        'high_values' => { 'count' => 5 },
+        'less_equal_min_value' => { 'count' => 3 },
+        'between_min_value_and_max_value' => { 'count' => 9 }
+      })
+    end
+
+  end
+
+  describe SumDistinctAggregation do
+
+    it "should build a terms aggregation over a field" do
+      agg = SumDistinctAggregation.new :user, :sum, :money
+      expected_result = {
+        terms: { field: :user, size: 0 },
+        aggs: {
+          sum_money: {
+            sum: { field: :money }
+          }
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should build a terms aggregation over a field with custom params" do
+      agg = SumDistinctAggregation.new :user, :sum, :money, script: 'your_script'
+      expected_result = {
+        terms: { field: :user, size: 0, script: 'your_script' },
+        aggs: {
+          sum_money: {
+            sum: { field: :money }
+          }
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should map a 'sum distinct' response" do
+      agg = SumDistinctAggregation.new :field, :max, :number, size: 5
+      response = { 'buckets' => [
+        { 'key' => 'value1', 'doc_count' => 'count1', 'max_number' => { 'value' => 12 } },
+        { 'key' => 'value2', 'doc_count' => 'count2', 'max_number' => { 'value' => 55 } },
+        { 'key' => 'value3', 'doc_count' => 'count3', 'max_number' => { 'value' => 32 } }
+      ] }
+      expect(agg.parse(response)).to eq(12 + 55 + 32)
+    end
+
+  end
+
+  describe TopHitsAggregation do
+
+    def open_response(name)
+      JSON.parse File.read "spec/#{name}.json"
+    end
+
+    it "should build a 'top hits' aggregation" do
+      agg = TopHitsAggregation.new :some_name do |q|
+        q.size 5
+        q.sort :username, :desc
+        q.source :username
+      end
+      expected_result = {
+        top_hits: {
+          size: 5,
+          sort: [{ username: { order: :desc } }],
+          _source: [:username]
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should map a 'top hits' response" do
+      agg = TopHitsAggregation.new :some_name
+      response = open_response 'elasticsearch_top_hits_response'
+      result = agg.parse response
+      # expect(result.total).to eq 25365
+      # expect(result.max_score).to eq 1
+      # expect(result.hits.count).to eq 1
+      # document = result.hits.first
+      expect(result.count).to eq 1
+      document = result.first
+      expect(document).to be_a Document
+      expect(document.index).to eq 'stack'
+      expect(document.type).to eq 'question'
+      expect(document.source['title']).to eq 'Windows port opening'
+    end
+
+  end
+
+  describe CustomAggregation do
+
+    it "should build a custom aggregation" do
+      agg = CustomAggregation.new :my_agg do
+        { custom_aggregation: { field: :some_field } }
+      end
+      expected_result = {
+        custom_aggregation: {
+          field: :some_field
+        }
+      }
+      expect(agg.build).to eq expected_result
+    end
+
+    it "should map a custom aggregation response" do
+      agg = CustomAggregation.new :my_agg do
+        { custom_aggregation: { field: :some_field } }
+      end
+      response = { 'buckets' => [
+        { 'key' => 'value1', 'doc_count' => 'count1', 'max_number' => { 'value' => 12 } },
+        { 'key' => 'value2', 'doc_count' => 'count2', 'max_number' => { 'value' => 55 } },
+        { 'key' => 'value3', 'doc_count' => 'count3', 'max_number' => { 'value' => 32 } }
+      ] }
+      expect(agg.parse(response)).to eq response
+    end
+
+  end
+
+end