elasticated 1.0.0

data/spec/date_field_delimiter_spec.rb

@@ -0,0 +1,67 @@
+require_relative 'spec_helper'
+
+module Elasticated
+  module Delimiters
+    describe DateFieldDelimiter do
+
+      let :delimiter do
+        DateFieldDelimiter.new field: :created_at, as: :date
+      end
+
+      it "should not delimit anything" do
+        params = delimiter.build_strategy_params
+        expect(params).to be_empty
+      end
+
+      it "should delimit by one term" do
+        delimiter.add_term :created_at, '2016-07-19'
+        params = delimiter.build_strategy_params
+        expect(params).to eq date: '2016-07-19'
+      end
+
+      it "should raise  when delimit by multiple terms" do
+        delimiter.add_term :created_at, 'nombre1'
+        delimiter.add_term :created_at, 'nombre2'
+        expect{ delimiter.build_strategy_params }.to raise_error
+      end
+
+      it "should delimit by a min date" do
+        delimiter.set_minimum :created_at, '2016-07-19'
+        params = delimiter.build_strategy_params
+        expect(params).to eq date_since: '2016-07-19'
+      end
+
+      it "should delimit by a max date" do
+        delimiter.set_maximum :created_at, '2016-07-19'
+        params = delimiter.build_strategy_params
+        expect(params).to eq date_until: '2016-07-19'
+      end
+
+      it "should delimit by a range of dates" do
+        delimiter.set_minimum :created_at, '2016-07-19'
+        delimiter.set_maximum :created_at, '2016-07-21'
+        params = delimiter.build_strategy_params
+        expect(params).to eq date_since: '2016-07-19', date_until: '2016-07-21'
+      end
+
+      it "should delimit by the most restricted range of dates" do
+        delimiter.set_minimum :created_at, '2016-07-19'
+        delimiter.set_maximum :created_at, '2016-07-25'
+        delimiter.set_minimum :created_at, '2016-07-17' # ignored minimum
+        delimiter.set_maximum :created_at, '2016-07-24'
+        delimiter.set_maximum :created_at, '2016-07-26' # ignored maximum
+        params = delimiter.build_strategy_params
+        expect(params).to eq date_since: '2016-07-19', date_until: '2016-07-24'
+      end
+
+      it "should prefer a term over a range of dates" do
+        delimiter.set_minimum :created_at, '2016-07-19'
+        delimiter.set_maximum :created_at, '2016-07-21'
+        delimiter.add_term :created_at, '2016-07-20'
+        params = delimiter.build_strategy_params
+        expect(params).to eq date: '2016-07-20'
+      end
+
+    end
+  end
+end

data/spec/document_spec.rb

@@ -0,0 +1,44 @@
+require_relative 'spec_helper'
+
+module Elasticated
+  describe Document do
+
+    def open_hit(name)
+      JSON.parse File.read "spec/#{name}.json"
+    end
+
+    let :hit do
+      open_hit 'elasticsearch_hit_1'
+    end
+
+    it "should parse an elasticsearch hit" do
+      document = Document.from_elasticsearch_hit hit
+      expect(document.id).to eq 'AU-CLCguwlaKln07OA4x'
+      expect(document.index).to eq 'fbinsights-v6-2015-08'
+      expect(document.type).to eq 'post'
+      expect(document.score).to eq 7.6152167
+      expect(document.source).not_to be_nil
+      expect(document.source.keys.count).to eq 6
+    end
+
+    context "the document source" do
+
+      it "can be accessed via methods" do
+        document = Document.from_elasticsearch_hit hit
+        expect(document.source.page_id).to eq '127735990588679'
+      end
+
+      it "can be accessed via key" do
+        document = Document.from_elasticsearch_hit hit
+        expect(document.source['page_id']).to eq '127735990588679'
+      end
+
+      it "can be accessed via indifferent key" do
+        document = Document.from_elasticsearch_hit hit
+        expect(document.source[:page_id]).to eq '127735990588679'
+      end
+
+    end
+
+  end
+end

data/spec/elasticsearch_hit_1.json

@@ -0,0 +1,14 @@
+{
+  "_index": "fbinsights-v6-2015-08",
+  "_type": "post",
+  "_id": "AU-CLCguwlaKln07OA4x",
+  "_score": 7.6152167,
+  "_source": {
+    "date": "2015-08-31",
+    "type": "post",
+    "element_id": "127735990588679_1074565052572430",
+    "social_content_id": "127735990588679_1074565052572430-QuilmesMoniFBPost-inbox-68",
+    "page_id": "127735990588679",
+    "sub_type": "link"
+  }
+}

data/spec/elasticsearch_response_1.json

@@ -0,0 +1,29 @@
+{
+  "took": 106,
+  "timed_out": false,
+  "_shards": {
+    "total": 3,
+    "successful": 3,
+    "failed": 0
+  },
+  "hits": {
+    "total": 1,
+    "max_score": 15.003607,
+    "hits": [
+      {
+        "_index": "fbinsights-v6-2015-08",
+        "_type": "post",
+        "_id": "AU-TsZrUyuAii-shqAtn",
+        "_score": 15.003607,
+        "_source": {
+          "element_id": "69004099657_10153641105209658",
+          "element_created_at": "2015-08-31T17:40:43.000Z",
+          "page_id": "69004099657",
+          "date": "2015-08-31",
+          "sub_type": "photo",
+          "type": "post"
+        }
+      }
+    ]
+  }
+}

data/spec/elasticsearch_response_2.json

@@ -0,0 +1,44 @@
+{
+  "took": 140,
+  "timed_out": false,
+  "_shards": {
+    "total": 3,
+    "successful": 3,
+    "failed": 0
+  },
+  "hits": {
+    "total": 340,
+    "max_score": 7.6152167,
+    "hits": [
+      {
+        "_index": "fbinsights-v6-2015-08",
+        "_type": "post",
+        "_id": "AU-CLCguwlaKln07OA4x",
+        "_score": 7.6152167,
+        "_source": {
+          "date": "2015-08-31",
+          "type": "post",
+          "element_id": "127735990588679_1074565052572430",
+          "social_content_id": "127735990588679_1074565052572430-QuilmesMoniFBPost-inbox-68",
+          "page_id": "127735990588679",
+          "sub_type": "link"
+        }
+      }
+    ]
+  },
+  "aggregations": {
+    "ads": {
+      "doc_count": 259,
+      "group_by_adgroup": {
+        "doc_count_error_upper_bound": 3,
+        "sum_other_doc_count": 360,
+        "buckets": [
+          {
+            "key": "6023316427914",
+            "doc_count": 1
+          }
+        ]
+      }
+    }
+  }
+}

data/spec/elasticsearch_top_hits_response.json

@@ -0,0 +1,20 @@
+{
+  "hits": {
+    "total": 25365,
+    "max_score": 1,
+    "hits": [
+      {
+        "_index": "stack",
+        "_type": "question",
+        "_id": "602679",
+        "_score": 1,
+        "_source": {
+          "title": "Windows port opening"
+        },
+        "sort": [
+          1370143231177
+        ]
+      }
+   ]
+  }
+}

data/spec/integration_spec.rb

@@ -0,0 +1,184 @@
+require_relative 'spec_helper'
+
+module Elasticated
+  describe "Integrations" do
+
+    it "should build a complex query" do
+      query = Query.build do
+        conditions{ equal :first_name, :pablo; equal :last_name, :fernandez }
+        filter{ equal :age, 23 }
+        aggregations do
+          group :materia do
+            max :nota
+          end
+        end
+        size 20
+        from 5
+        sort :element_id
+        source :nota
+      end
+      expect(query.build).to eq(
+        query: {
+          filtered: {
+            filter: {
+              terms: { age: [23] }
+            },
+            query: {
+              bool: {
+                must: [
+                  { terms: { first_name: [:pablo] } },
+                  { terms: { last_name: [:fernandez] } }
+                ]
+              }
+            }
+          }
+        },
+        aggs: {
+          group_by_materia: {
+            terms: { field: :materia, size: 0 },
+            aggs: {
+              max_nota: {
+                max: { field: :nota }
+              }
+            }
+          }
+        },
+        size: 20,
+        from: 5,
+        _source: [:nota],
+        sort: [{ element_id: { order: :asc } }]
+      )
+    end
+
+    it "should merge complex aggregations" do
+      query = Query.build do
+        aggregations do
+          date_histogram :date, interval: '7d' do
+            group :user do
+              count_filtered(:element_id){ equal :element_id, 2 }
+            end
+            nested 'path' do
+              group 'path.metric.name', as: 'metric' do
+                max 'path.metric.value', as: 'metric_value'
+              end
+            end
+          end
+        end
+      end
+      query.aggregations do
+        nested 'path'
+        date_histogram :date, interval: '7d' do
+          nested 'path' do
+            group 'path.metric.name', as: 'metric' do
+              max 'path.metric.value', as: 'some_value'
+            end
+          end
+        end
+      end
+      expect(query.build).to eq(
+        query: { match_all: {} },
+        aggs: {
+          path: {
+            nested: { path: 'path' }
+          },
+          group_by_date: {
+            date_histogram: { field: :date, interval: '7d', format: 'yyyy-MM-dd' },
+            aggs: {
+              group_by_user: {
+                terms: { field: :user, size: 0 },
+                aggs: {
+                  element_id: {
+                    filter: { terms: { element_id: [2] } }
+                  }
+                }
+              },
+              path: {
+                nested: { path: 'path' },
+                aggs: {
+                  metric: {
+                    terms: { field: 'path.metric.name', size: 0 },
+                    aggs: {
+                      metric_value: {
+                        max: { field: 'path.metric.value' }
+                      },
+                      some_value: {
+                        max: { field: 'path.metric.value' }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      )
+    end
+
+    it "should build queries and return results on aggregations including special chars" do
+      query = Query.build do
+        conditions{ equal :first_name, :pablo; equal :last_name, :fernandez }
+        filter{ equal :age, 23 }
+        aggregations do
+          group :materia, {as: "materia <+> nota"}
+        end
+        size 20
+        from 5
+        sort :element_id
+        source :nota
+      end
+      expect(query.build).to eq(
+        query: {
+          filtered: {
+            filter: {
+              terms: { age: [23] }
+            },
+            query: {
+              bool: {
+                must: [
+                  { terms: { first_name: [:pablo] } },
+                  { terms: { last_name: [:fernandez] } }
+                ]
+              }
+            }
+          }
+        },
+        aggs: {
+          materia_____nota: {
+            terms: { field: :materia, size: 0 },
+          }
+        },
+        size: 20,
+        from: 5,
+        _source: [:nota],
+        sort: [{ element_id: { order: :asc } }]
+      )
+      expect(
+        query.parse_aggregations(
+          {
+            "materia_____nota"=>
+            {
+              "buckets" =>
+              [
+                {
+                  "key"=>"user1",
+                  "doc_count"=>2
+                }
+              ]
+            }
+          }
+        )
+      ).to eq(
+        {
+          "materia <+> nota" =>
+          {
+            "user1" =>
+            {
+              "count" => 2
+            }
+          }
+        }
+      )
+    end
+
+  end
+end

data/spec/mapping_spec.rb

@@ -0,0 +1,219 @@
+require_relative 'spec_helper'
+
+module Elasticated
+  describe Mapping do
+
+    it "should build a single integer property" do
+      result = Mapping.build do |mapping|
+        mapping.type :a_type do |type|
+          type.integer :an_integer
+        end
+      end
+      expected_result = {
+          a_type: {
+            properties: {
+              an_integer: { type: :integer, fielddata: { format: :doc_values } }
+            }
+          }
+        }
+      expect(result).to eq expected_result
+    end
+
+    it "should build a single long property" do
+      result = Mapping.build do |mapping|
+        mapping.type :a_type do |type|
+          type.long :a_long
+        end
+      end
+      expected_result = {
+          a_type: {
+            properties: {
+              a_long: { type: :long, fielddata: { format: :doc_values } }
+            }
+          }
+        }
+      expect(result).to eq expected_result
+    end
+
+    it "should build a single date property" do
+      result = Mapping.build do |mapping|
+        mapping.type :a_type do |type|
+          type.date :a_date
+        end
+      end
+      expected_result = {
+          a_type: {
+            properties: {
+              a_date: { type: :date, fielddata: { format: :doc_values } }
+            }
+          }
+        }
+      expect(result).to eq expected_result
+    end
+
+    it "should build a single string property" do
+      result = Mapping.build do |mapping|
+        mapping.type :a_type do |type|
+          type.string :a_string
+        end
+      end
+      expected_result = {
+          a_type: {
+            properties: {
+              a_string: { type: :string, index: :not_analyzed, fielddata: { format: :doc_values } }
+            }
+          }
+        }
+      expect(result).to eq expected_result
+    end
+
+    it "should build a single analyzed string property" do
+      result = Mapping.build do |mapping|
+        mapping.type :a_type do |type|
+          type.analyzed_string :a_string
+        end
+      end
+      expected_result = {
+          a_type: {
+            properties: {
+              a_string: {
+                type: :multi_field,
+                fields: {
+                  a_string: { type: :string, index: :not_analyzed, fielddata: { format: :doc_values } },
+                  analyzed: { type: :string }
+                }
+              }
+            }
+          }
+        }
+      expect(result).to eq expected_result
+    end
+
+    it "should build a single bool property" do
+      result = Mapping.build do |mapping|
+        mapping.type :a_type do |type|
+          type.bool :a_bool
+        end
+      end
+      expected_result = {
+          a_type: {
+            properties: {
+              a_bool: { type: :boolean }
+            }
+          }
+        }
+      expect(result).to eq expected_result
+    end
+
+    it "should build a single object" do
+      result = Mapping.build do |mapping|
+        mapping.type :a_type do |type|
+          type.object :an_object do |object|
+            object.string :a_string
+          end
+        end
+      end
+      expected_result = {
+          a_type: {
+            properties: {
+              an_object: {
+                type: :object,
+                properties: {
+                  a_string: { type: :string, index: :not_analyzed, fielddata: { format: :doc_values } }
+                }
+              }
+            }
+          }
+        }
+      expect(result).to eq expected_result
+    end
+
+    it "should build a single nested" do
+      result = Mapping.build do |mapping|
+        mapping.type :a_type do |type|
+          type.nested :a_nested do |object|
+            object.string :a_key
+            object.long :a_value
+          end
+        end
+      end
+      expected_result = {
+          a_type: {
+            properties: {
+              a_nested: {
+                type: :nested,
+                properties: {
+                  a_key: { type: :string, index: :not_analyzed, fielddata: { format: :doc_values } },
+                  a_value: { type: :long, fielddata: { format: :doc_values } }
+                }
+              }
+            }
+          }
+        }
+      expect(result).to eq expected_result
+    end
+
+    it "should build a complex mapping" do
+      result = Mapping.build do |mapping|
+        mapping.type :post do |type|
+          type.string :username
+          type.analyzed_string :element_id
+          type.object :day do |object|
+            object.long :impressions
+          end
+          type.object :lifetime do |object|
+            object.long :impressions
+            object.object :reach do |reach|
+              reach.object :origin do |origin|
+                origin.string :name
+                origin.string :from
+              end
+            end
+          end
+        end
+        mapping.type :user do |type|
+          type.date :date
+        end
+      end
+      expected_result = {
+        user: {
+          properties: {
+            date: { type: :date, fielddata: { format: :doc_values } }
+          }
+        },
+        post: {
+          properties: {
+            username: { type: :string, index: :not_analyzed, fielddata: { format: :doc_values } },
+            element_id: {
+              type: :multi_field,
+              fields: {
+                a_string: { type: :string, index: :not_analyzed, fielddata: { format: :doc_values } },
+                analyzed: { type: :string }
+              }
+            },
+            day: {
+              type: :object,
+              properties: {
+                impressions: { type: :long, fielddata: { format: :doc_values } }
+              }
+            },
+            lifetime: {
+              type: :object,
+              properties: {
+                impressions: { type: :long, fielddata: { format: :doc_values } },
+                reach: {
+                  type: :object,
+                  properties: {
+                    name: { type: :string, index: :not_analyzed, fielddata: { format: :doc_values } },
+                    from: { type: :string, index: :not_analyzed, fielddata: { format: :doc_values } }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    end
+
+  end
+end