elasticsearch-dsl 0.0.0 → 0.1.0

data/test/integration/search_aggregation_nested_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class NestedAggregationIntegrationTest < ::Elasticsearch::Test::IntegrationTestCase
+      include Elasticsearch::DSL::Search
+
+      context "A nested aggregation" do
+        startup do
+          Elasticsearch::Extensions::Test::Cluster.start(nodes: 1) if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running?
+        end
+
+        setup do
+          @client.indices.create index: 'products-test', body: {
+            mappings: {
+              product: {
+                properties: {
+                  offers: {
+                    type: 'nested',
+                    properties: {
+                      name:  { type: 'string' },
+                      price: { type: 'double' }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          @client.index index: 'products-test', type: 'product',
+                        body: { title: 'A',
+                                category: 'audio',
+                                offers: [ { name: 'A1', price: 100 }, { name: 'A2', price: 120 } ] }
+          @client.index index: 'products-test', type: 'product',
+                        body: { title: 'B',
+                                category: 'audio',
+                                offers: [ { name: 'B1', price: 200 }, { name: 'B2', price: 180 } ] }
+          @client.index index: 'products-test', type: 'product',
+                        body: { title: 'C',
+                                category: 'video',
+                                offers: [ { name: 'C1', price: 300 }, { name: 'C2', price: 350 } ] }
+          @client.indices.refresh index: 'products-test'
+        end
+
+        should "return the minimal price from offers" do
+          response = @client.search index: 'products-test', body: search {
+            query { match title: 'A' }
+
+            aggregation :offers do
+              nested do
+                path 'offers'
+                aggregation :min_price do
+                  min field: 'offers.price'
+                end
+              end
+            end
+          }.to_hash
+
+          assert_equal 100, response['aggregations']['offers']['min_price']['value'].to_i
+        end
+
+        should "return the top categories for offer price range" do
+          response = @client.search index: 'products-test', body: search {
+            query do
+              filtered do
+                filter do
+                  nested do
+                    path 'offers'
+                    filter do
+                      range 'offers.price' do
+                        gte 100
+                        lte 300
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            aggregation :offers do
+              nested do
+                path 'offers'
+                aggregation :top_categories do
+                  reverse_nested do
+                    aggregation :top_category_per_offer do
+                      terms field: 'category'
+                    end
+                  end
+                end
+              end
+            end
+          }.to_hash
+
+          assert_equal 2, response['aggregations']['offers']['top_categories']['top_category_per_offer']['buckets'].size
+          assert_equal 'audio', response['aggregations']['offers']['top_categories']['top_category_per_offer']['buckets'][0]['key']
+          assert_equal 'video', response['aggregations']['offers']['top_categories']['top_category_per_offer']['buckets'][1]['key']
+        end
+      end
+    end
+  end
+end

data/test/integration/search_aggregations_test.rb

@@ -0,0 +1,232 @@
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class AggregationsIntegrationTest < ::Elasticsearch::Test::IntegrationTestCase
+      include Elasticsearch::DSL::Search
+
+      context "Aggregations integration" do
+        setup do
+          @client.indices.create index: 'test'
+          @client.index index: 'test', type: 'd', id: '1', body: { title: 'A', tags: %w[one], clicks: 5 }
+          @client.index index: 'test', type: 'd', id: '2', body: { title: 'B', tags: %w[one two], clicks: 15 }
+          @client.index index: 'test', type: 'd', id: '3', body: { title: 'C', tags: %w[one three], clicks: 20 }
+          @client.indices.refresh index: 'test'
+        end
+
+        context "with a terms aggregation" do
+          should "return tag counts" do
+            response = @client.search index: 'test', body: search {
+              aggregation :tags do
+                terms field: 'tags'
+              end
+            }.to_hash
+
+            assert_equal 3, response['aggregations']['tags']['buckets'].size
+            assert_equal 'one', response['aggregations']['tags']['buckets'][0]['key']
+          end
+
+          should "return approximate tag counts" do
+            response = @client.search index: 'test', body: search {
+              aggregation :tags do
+                cardinality field: 'tags'
+              end
+            }.to_hash
+
+            assert_equal 3, response['aggregations']['tags']['value']
+          end
+
+          should "return tag counts per clicks range" do
+            response = @client.search index: 'test', body: search {
+              aggregation :clicks do
+                range field: 'clicks' do
+                  key :low, to: 10
+                  key :mid, from: 10, to: 20
+
+                  aggregation :tags do
+                    terms field: 'tags'
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 2, response['aggregations']['clicks']['buckets'].size
+            assert_equal 1, response['aggregations']['clicks']['buckets']['low']['doc_count']
+            assert_equal 'one', response['aggregations']['clicks']['buckets']['low']['tags']['buckets'][0]['key']
+          end
+
+          should "define multiple aggregations" do
+            response = @client.search index: 'test', body: search {
+              aggregation :clicks do
+                range field: 'clicks' do
+                  key :low, to: 10
+                  key :mid, from: 10, to: 20
+
+                  aggregation :tags do
+                    terms { field 'tags' }
+                  end
+                end
+              end
+
+              aggregation :min_clicks do
+                min field: 'clicks'
+              end
+
+              aggregation :max_clicks do
+                max field: 'clicks'
+              end
+
+              aggregation :sum_clicks do
+                sum field: 'clicks'
+              end
+
+              aggregation :avg_clicks do
+                avg field: 'clicks'
+              end
+            }.to_hash
+
+            assert_equal 2, response['aggregations']['clicks']['buckets'].size
+            assert_equal 1, response['aggregations']['clicks']['buckets']['low']['doc_count']
+            assert_equal 'one', response['aggregations']['clicks']['buckets']['low']['tags']['buckets'][0]['key']
+
+            assert_equal 5,  response['aggregations']['min_clicks']['value']
+            assert_equal 20, response['aggregations']['max_clicks']['value']
+            assert_equal 40, response['aggregations']['sum_clicks']['value']
+            assert_equal 13, response['aggregations']['avg_clicks']['value'].to_i
+          end
+
+          should "return statistics on clicks" do
+            response = @client.search index: 'test', body: search {
+              aggregation :stats_clicks do
+                stats field: 'clicks'
+              end
+              aggregation :value_count do
+                value_count field: 'clicks'
+              end
+            }.to_hash
+
+            assert_equal 3,  response['aggregations']['stats_clicks']['count']
+            assert_equal 5,  response['aggregations']['stats_clicks']['min']
+            assert_equal 20, response['aggregations']['stats_clicks']['max']
+            assert_equal 40, response['aggregations']['stats_clicks']['sum']
+            assert_equal 13, response['aggregations']['stats_clicks']['avg'].to_i
+            assert_equal 3,  response['aggregations']['value_count']['value']
+          end
+
+          should "return percentiles on clicks" do
+            response = @client.search index: 'test', body: search {
+              aggregation :percentiles do
+                percentiles field: 'clicks'
+              end
+            }.to_hash
+
+            assert_equal 20, response['aggregations']['percentiles']['values']['99.0'].round
+          end
+
+          should "return percentile ranks on clicks" do
+            response = @client.search index: 'test', body: search {
+              aggregation :percentiles do
+                percentile_ranks field: 'clicks', values: [5]
+              end
+            }.to_hash
+
+            assert_equal 17, response['aggregations']['percentiles']['values']['5.0'].round
+          end
+
+          should "return top hits per tag" do
+            response = @client.search index: 'test', body: search {
+              aggregation :tags do
+                terms do
+                  field 'tags'
+                  size  5
+
+                  aggregation :top_hits do
+                    top_hits sort: [ clicks: { order: 'desc' } ], _source: { include: 'title' }
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 3, response['aggregations']['tags']['buckets'][0]['top_hits']['hits']['hits'].size
+            assert_equal 'C', response['aggregations']['tags']['buckets'][0]['top_hits']['hits']['hits'][0]['_source']['title']
+          end
+
+          should "calculate clicks for a tag" do
+            response = @client.search index: 'test', body: search {
+              aggregation :clicks_for_one do
+                scripted_metric do
+                  init_script "_agg['transactions'] = []"
+                  map_script  "if (doc['tags'].value.contains('one')) { _agg.transactions.add(doc['clicks'].value) }"
+                  combine_script "sum = 0; for (t in _agg.transactions) { sum += t }; return sum"
+                  reduce_script "sum = 0; for (a in _aggs) { sum += a }; return sum"
+                end
+              end
+            }.to_hash
+
+            assert_equal 40, response['aggregations']['clicks_for_one']['value']
+          end
+
+          should "limit the scope with a filter" do
+            response = @client.search index: 'test', body: search {
+              aggregation :clicks_for_one do
+                filter terms: { tags: ['one'] } do
+                  aggregation :sum_clicks do
+                    sum field: 'clicks'
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 40, response['aggregations']['clicks_for_one']['sum_clicks']['value']
+          end
+        end
+
+        should "return aggregations for multiple filters" do
+          response = @client.search index: 'test', body: search {
+            aggregation :avg_clicks_per_tag do
+              filters do
+                filters one: { terms: { tags: ['one'] } },
+                        two: { terms: { tags: ['two'] } }
+                aggregation :avg do
+                  avg field: 'clicks'
+                end
+              end
+            end
+          }.to_hash
+
+          assert_equal 13, response['aggregations']['avg_clicks_per_tag']['buckets']['one']['avg']['value'].to_i
+          assert_equal 15, response['aggregations']['avg_clicks_per_tag']['buckets']['two']['avg']['value'].to_i
+        end
+
+        should "return a histogram on clicks" do
+          response = @client.search index: 'test', body: search {
+            aggregation :clicks_histogram do
+              histogram do
+                field   'clicks'
+                interval 10
+              end
+            end
+          }.to_hash
+
+          assert_equal 3,  response['aggregations']['clicks_histogram']['buckets'].size
+          assert_equal 10, response['aggregations']['clicks_histogram']['buckets'][1]['key']
+          assert_equal 1,  response['aggregations']['clicks_histogram']['buckets'][1]['doc_count']
+        end
+
+        should "return a histogram with empty buckets on clicks" do
+          response = @client.search index: 'test', body: search {
+            aggregation :clicks_histogram do
+              histogram do
+                field   'clicks'
+                interval 2
+                min_doc_count 0
+              end
+            end
+          }.to_hash
+
+          assert_equal 9, response['aggregations']['clicks_histogram']['buckets'].size
+        end
+      end
+    end
+  end
+end

data/test/integration/search_filters_test.rb

@@ -0,0 +1,359 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+module Elasticsearch
+  module Test
+    class FiltersIntegrationTest < ::Elasticsearch::Test::IntegrationTestCase
+      include Elasticsearch::DSL::Search
+
+      context "Filters integration" do
+        startup do
+          Elasticsearch::Extensions::Test::Cluster.start(nodes: 1) if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running?
+        end
+
+        setup do
+          @client.indices.create index: 'test'
+          @client.index index: 'test', type: 'd', id: 1,
+                        body: { name: 'Original',
+                                color: 'red',
+                                size: 'xxl',
+                                category: 'unisex',
+                                manufacturer: 'a' }
+
+          @client.index index: 'test', type: 'd', id: 2,
+                        body: { name: 'Original',
+                                color: 'red',
+                                size: 'xl',
+                                category: 'unisex',
+                                manufacturer: 'a' }
+
+          @client.index index: 'test', type: 'd', id: 3,
+                        body: { name: 'Original',
+                                color: 'red',
+                                size: 'l',
+                                category: 'unisex',
+                                manufacturer: 'a' }
+
+          @client.index index: 'test', type: 'd', id: 4,
+                        body: { name: 'Western',
+                                color: 'red',
+                                size: 'm',
+                                category: 'men',
+                                manufacturer: 'c' }
+
+          @client.index index: 'test', type: 'd', id: 5,
+                        body: { name: 'Modern',
+                                color: 'grey',
+                                size: 'l',
+                                category: 'men',
+                                manufacturer: 'b' }
+
+          @client.index index: 'test', type: 'd', id: 6,
+                        body: { name: 'Modern',
+                                color: 'grey',
+                                size: 's',
+                                category: 'men',
+                                manufacturer: 'b' }
+
+          @client.index index: 'test', type: 'd', id: 7,
+                        body: { name: 'Modern',
+                                color: 'grey',
+                                size: 's',
+                                category: 'women',
+                                manufacturer: 'b' }
+
+          @client.indices.refresh index: 'test'
+        end
+
+        context "term filter" do
+          should "return matching documents" do
+            response = @client.search index: 'test', body: search {
+              query do
+                filtered do
+                  filter do
+                    term color: 'red'
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 4, response['hits']['total']
+            assert response['hits']['hits'].all? { |h| h['_source']['color'] == 'red'  }, response.inspect
+          end
+        end
+
+        context "terms filter" do
+          should "return matching documents" do
+            response = @client.search index: 'test', body: search {
+              query do
+                filtered do
+                  filter do
+                    terms color: ['red', 'grey', 'gold']
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 7, response['hits']['total']
+          end
+        end
+
+        context "and/or/not filters" do
+          should "find the document with and as a Hash" do
+            response = @client.search index: 'test', body: search {
+              query do
+                filtered do
+                  filter do
+                    _and filters: [ { term: { color: 'red' } }, { term: { size: 'xxl' } } ]
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 1, response['hits']['total']
+          end
+
+          should "find the document with and as a block" do
+            response = @client.search index: 'test', body: search {
+              query do
+                filtered do
+                  filter do
+                    _and do
+                      term color: 'red'
+                      term size:  'xxl'
+                    end
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 1, response['hits']['total']
+          end
+
+          should "find the documents with or" do
+            response = @client.search index: 'test', body: search {
+              query do
+                filtered do
+                  filter do
+                    _or do
+                      term size: 'l'
+                      term size: 'm'
+                    end
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 3, response['hits']['total']
+            assert response['hits']['hits'].all? { |h| ['l', 'm'].include? h['_source']['size']  }
+          end
+
+          should "find the documents with not as a Hash" do
+            response = @client.search index: 'test', body: search {
+              query do
+                filtered do
+                  filter do
+                    _not term: { size: 'xxl' }
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 6, response['hits']['total']
+            assert response['hits']['hits'].none? { |h| h['_source']['size'] == 'xxl' }
+          end
+
+          should "find the documents with not as a block" do
+            response = @client.search index: 'test', body: search {
+              query do
+                filtered do
+                  filter do
+                    _not do
+                      term size: 'xxl'
+                    end
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 6, response['hits']['total']
+            assert response['hits']['hits'].none? { |h| h['_source']['size'] == 'xxl' }
+          end
+        end
+
+        context "bool filter" do
+          should "return correct documents" do
+            response = @client.search index: 'test', body: search {
+              query do
+                filtered do
+                  filter do
+                    bool do
+                      must do
+                        term size:  'l'
+                      end
+
+                      should do
+                        term color: 'red'
+                      end
+
+                      should do
+                        term category: 'men'
+                      end
+
+                      must_not do
+                        term manufacturer: 'b'
+                      end
+                    end
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 1,   response['hits']['hits'].size
+            assert_equal '3', response['hits']['hits'][0]['_id'].to_s
+          end
+        end
+
+        context "geographical filters" do
+          setup do
+            @client.indices.create index: 'places', body: {
+              mappings: {
+                d: {
+                  properties: {
+                    location: {
+                      type: 'geo_point',
+                      geohash: true,
+                      geohash_prefix: true,
+                      geohash_precision: 6
+                    }
+                  }
+                }
+              }
+            }
+            @client.index index: 'places', type: 'd', id: 1,
+                          body: { name: 'Vyšehrad',
+                                  location: '50.064399, 14.420018'}
+
+            @client.index index: 'places', type: 'd', id: 2,
+                          body: { name: 'Karlštejn',
+                                  location: '49.939518, 14.188046'}
+
+            @client.indices.refresh index: 'places'
+          end
+
+          should "find documents within the bounding box" do
+            response = @client.search index: 'places', body: search {
+              query do
+                filtered do
+                  filter do
+                    geo_bounding_box :location do
+                      top_right   "50.1815123678,14.7149200439"
+                      bottom_left "49.9415476869,14.2162566185"
+                    end
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 1, response['hits']['hits'].size
+            assert_equal 'Vyšehrad', response['hits']['hits'][0]['_source']['name']
+          end
+
+          should "find documents within the distance specified with a hash" do
+            response = @client.search index: 'places', body: search {
+              query do
+                filtered do
+                  filter do
+                    geo_distance location: '50.090223,14.399590', distance: '5km'
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 1, response['hits']['hits'].size
+            assert_equal 'Vyšehrad', response['hits']['hits'][0]['_source']['name']
+          end
+
+          should "find documents within the distance specified with a block" do
+            response = @client.search index: 'places', body: search {
+              query do
+                filtered do
+                  filter do
+                    geo_distance :location do
+                      lat '50.090223'
+                      lon '14.399590'
+                      distance '5km'
+                    end
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 1, response['hits']['hits'].size
+            assert_equal 'Vyšehrad', response['hits']['hits'][0]['_source']['name']
+          end
+
+          should "find documents within the geographical distance range" do
+            response = @client.search index: 'places', body: search {
+              query do
+                filtered do
+                  filter do
+                    geo_distance_range location: { lat: '50.090223', lon: '14.399590' },
+                                       gte: '10km', lte: '50km'
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 1, response['hits']['hits'].size
+            assert_equal 'Karlštejn', response['hits']['hits'][0]['_source']['name']
+          end
+
+          should "find documents within the polygon" do
+            response = @client.search index: 'places', body: search {
+              query do
+                filtered do
+                  filter do
+                    geo_polygon :location do
+                      points [
+                       [14.2244355,49.9419006],
+                       [14.2244355,50.1774301],
+                       [14.7067869,50.1774301],
+                       [14.7067869,49.9419006],
+                       [14.2244355,49.9419006]
+                      ]
+                    end
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 1, response['hits']['hits'].size
+            assert_equal 'Vyšehrad', response['hits']['hits'][0]['_source']['name']
+          end
+
+          should "find documents within the geohash cell" do
+            response = @client.search index: 'places', body: search {
+              query do
+                filtered do
+                  filter do
+                    geohash_cell :location do
+                      lat '50.090223'
+                      lon '14.399590'
+                      precision '10km'
+                      neighbors true
+                    end
+                  end
+                end
+              end
+            }.to_hash
+
+            assert_equal 1, response['hits']['hits'].size
+            assert_equal 'Vyšehrad', response['hits']['hits'][0]['_source']['name']
+          end
+        end
+      end
+    end
+  end
+end