elastic_adapter 0.0.8 → 0.1.0

data/spec/responses/aggregation_response_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-
-module ElasticAdapter
-  module Responses
-    describe AggregationResponse do
-      let(:response){{
-        aggregations: {
-          products: {
-            doc_count_error_upper_bound: 46,
-            buckets: [
-              {
-                key: "Product A",
-                doc_count: 100
-              },
-              {
-                key: "Product Z",
-                doc_count: 52
-              }
-            ]
-          }
-        }
-      }}
-
-      subject { AggregationResponse.new(response) }
-
-      describe "#aggregations" do
-        it "counts one" do
-          expect(subject.aggregations.count).to eq 1
-        end
-
-        it "contains products" do
-          expect(subject.aggregations).to have_key :products
-        end
-
-        describe "products" do
-          it "counts two" do
-            expect(subject.aggregations[:products].count).to eq 2
-          end
-
-          it "contains Product A with it's count" do
-            expect(subject.aggregations[:products]).to include({
-              term: "Product A",
-              count: 100
-            })
-          end
-
-          it "contains Product Z with it's count" do
-            expect(subject.aggregations[:products]).to include({
-              term: "Product Z",
-              count: 52
-            })
-          end
-        end
-      end
-    end
-  end
-end

data/spec/responses/base_response_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-module ElasticAdapter
-  module Responses
-    describe BaseResponse do
-      let(:object) { Class.new }
-
-      subject { BaseResponse.new(object) }
-
-      describe "delegation" do
-        describe "#object" do
-          it "returns the object" do
-            expect(subject.object).to be object
-          end
-        end
-      end
-    end
-  end
-end

data/spec/responses/count_response_spec.rb

@@ -1,24 +0,0 @@
-require "spec_helper"
-
-module ElasticAdapter
-  module Responses
-    describe CountResponse do
-      let(:response) {{
-        count: 1,
-        shards: {
-            total: 5,
-            successful: 5,
-            failed: 0
-        }
-      }}
-
-      subject { CountResponse.new(response) }
-
-      describe "#count" do
-        it "equals 1" do
-          expect(subject.count).to eq 1
-        end
-      end
-    end
-  end
-end

data/spec/responses/get_response_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-module ElasticAdapter
-  module Responses
-    describe GetResponse do
-      let(:response) {{
-        index: "twitter",
-        type: "tweet",
-        id: "1",
-        version: 1,
-        found: true,
-        source: {
-            user: "kimchy",
-            postDate: "2009-11-15T14:12:12",
-            message: "trying out Elasticsearch"
-        }
-      }}
-
-      subject { GetResponse.new(response) }
-
-      describe "#document" do
-        it "returns the source" do
-          expect(subject.document).to eq response[:source].merge(id: response[:id])
-        end
-      end
-
-    end
-  end
-end

data/spec/responses/response_decorator_factory_spec.rb

@@ -1,126 +0,0 @@
-require "spec_helper"
-
-module ElasticAdapter
-  module Responses
-    describe ResponseDecoratorFactory do
-      describe "class methods" do
-        describe "#decorate" do
-          context "count" do
-            let(:response) {{ acknowledged: true }}
-            subject { ResponseDecoratorFactory.decorate(response, :count) }
-
-            it "returns a CountResponse" do
-              expect(subject).to be_a CountResponse
-            end
-          end
-
-          context "get" do
-            let(:response) {{ source: {} }}
-            subject { ResponseDecoratorFactory.decorate(response, :get) }
-
-            it "returns a GetResponse" do
-              expect(subject).to be_a GetResponse
-            end
-          end
-
-          context "search" do
-            let(:response) {{ hits: {hits: []} }}
-            subject { ResponseDecoratorFactory.decorate(response, :search) }
-
-            it "returns a SearchResponse" do
-              expect(subject).to be_a SearchResponse
-            end
-          end
-
-          context "validation" do
-            let(:response) {{ valid: true }}
-            subject { ResponseDecoratorFactory.decorate(response, :validation) }
-
-            it "returns a ValidationResponse" do
-              expect(subject).to be_a ValidationResponse
-            end
-          end
-
-          context "suggestion" do
-            let(:response) {{
-              my_suggest_1: [
-                {
-                  text: "amsterdma",
-                  offset: 4,
-                  length: 9,
-                  options: [
-                    {
-                      text: "amsterdam",
-                      freq: 77,
-                      score: 0.8888889
-                    }
-                  ]
-                }
-              ]
-            }}
-            subject { ResponseDecoratorFactory.decorate(response, :suggestion) }
-
-            it "returns a SuggestionResponse" do
-              expect(subject).to be_a SuggestionResponse
-            end
-          end
-
-          context "aggregation" do
-            let(:response){{
-              aggregations: {
-                products: {
-                  doc_count_error_upper_bound: 46,
-                  buckets: [
-                    {
-                      key: "Product A",
-                      doc_count: 100
-                    }
-                  ]
-                }
-              }
-            }}
-
-            subject { ResponseDecoratorFactory.decorate(response, :aggregation) }
-
-            it "returns a AggregationResponse" do
-              expect(subject).to be_a AggregationResponse
-            end
-          end
-
-          context "mixed aggregation and search" do
-            let(:response){{
-              hits: { hits: [] },
-              aggregations: {
-                products: {
-                  doc_count_error_upper_bound: 46,
-                  buckets: [
-                    {
-                      key: "Product A",
-                      doc_count: 100
-                    }
-                  ]
-                }
-              }
-            }}
-
-            subject { ResponseDecoratorFactory.decorate(response, :aggregation, :search) }
-
-            it "doent raise an exception" do
-              expect{
-                subject
-              }.not_to raise_error
-            end
-
-            it "behaves like a AggregationResponse" do
-              expect(subject).to respond_to :aggregations
-            end
-
-            it "behaves like a SearchResponse" do
-              expect(subject).to respond_to :count
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/responses/sanitized_response_spec.rb

@@ -1,36 +0,0 @@
-require "spec_helper"
-
-module ElasticAdapter
-  module Responses
-    describe SanitizedResponse do
-      describe "symbolize keys" do
-        it "turns all strings in Hash keys to symbols" do
-          hash = {"foo" => "bar"}
-          response = SanitizedResponse.new(hash)
-          expect(response.keys.first).to be_a Symbol
-        end
-
-        it "removes all leading underscores from keys" do
-          hash = {"_foo" => {"_bar" => "baz" }}
-          expected = {foo: {bar: "baz" }}
-          response = SanitizedResponse.new(hash)
-          expect(response.object).to eq expected
-        end
-
-        it "works with arrays" do
-          hash = { "foo" => ["bar", "buz"] }
-          expected = { foo: ["bar", "buz"] }
-          response = SanitizedResponse.new(hash)
-          expect(response.object).to eq expected
-        end
-
-        it "works with hashes in arrays" do
-          hash = { boo: [ {"foo" => ["bar", "buz"] } ] }
-          expected = { boo: [ {foo: ["bar", "buz"] } ] }
-          response = SanitizedResponse.new(hash)
-          expect(response.object).to eq expected
-        end
-      end
-    end
-  end
-end

data/spec/responses/search_response_spec.rb

@@ -1,122 +0,0 @@
-require "spec_helper"
-
-module ElasticAdapter
-  module Responses
-    describe SearchResponse do
-      let(:response) {{
-        shards: {
-          total: 5,
-          successful: 5,
-          failed: 0
-        },
-        hits: {
-          total: 1,
-          hits: [
-            {
-              index: "twitter",
-              type: "tweet",
-              id: "1",
-              source: {
-                user: "kimchy",
-                postDate: "2009-11-15T14:12:12",
-                message: "trying out Elasticsearch"
-              }
-            }
-          ]
-        },
-        aggregations: {
-          products: {
-            doc_count_error_upper_bound: 46,
-            buckets: [
-              {
-                key: "Product A",
-                doc_count: 100
-              },
-              {
-                key: "Product Z",
-                doc_count: 52
-              }
-            ]
-          }
-        },
-        suggest: {
-          foo_suggest: [
-            {
-              text: "ba",
-              offset: 0,
-              length: 2,
-              options: [
-                {
-                  text: "bar",
-                  score: 1.0
-                }
-              ]
-            }
-          ]
-        }
-      }}
-
-      subject { SearchResponse.new(response) }
-
-      context "empty response" do
-        let(:response) {{}}
-
-        it "should not fail" do
-          expect { subject }.not_to raise_error
-        end
-      end
-
-      describe "hits" do
-        it "returns the hits" do
-          expect(subject.hits).to include({
-            id: "1",
-            user: "kimchy",
-            postDate: "2009-11-15T14:12:12",
-            message: "trying out Elasticsearch"
-          })
-        end
-      end
-
-      describe "#aggregations" do
-        it "returns the aggregations" do
-          expect(subject.aggregations).to eq response[:aggregations]
-        end
-      end
-
-      describe "suggestions" do
-        it "is an array" do
-          expect(subject.suggestions).to be_an Array
-        end
-
-        describe "first suggestion" do
-          describe "#terms" do
-            it "is an Array" do
-              expect(subject.suggestions.first.terms).to be_an Array
-            end
-
-            it "counts one" do
-              expect(subject.suggestions.first.terms.count).to eq 1
-            end
-
-            describe "first term" do
-              describe "#text" do
-                it "equals 'ba'" do
-                  expect(subject.suggestions.first.terms.first.text).to eq "ba"
-                end
-
-                describe "#options" do
-                  it "includes the options" do
-                    expect(subject.suggestions.first.terms.first.options).to include({
-                      text: "bar",
-                      score: 1.0
-                    })
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/responses/suggestion_response_spec.rb

@@ -1,63 +0,0 @@
-require "spec_helper"
-
-module ElasticAdapter
-  module Responses
-    describe SuggestionResponse do
-      let(:response){{
-        shards: {
-          total: 5, successful: 5, failed: 0
-        },
-        foo_suggest: [
-          {
-            text: "ba",
-            offset: 0,
-            length: 2,
-            options: [
-              {
-                text: "bar",
-                score: 1.0
-              }
-            ]
-          }
-        ]
-      }}
-
-      describe "suggestions" do
-        subject { SuggestionResponse.new(response).suggestions }
-
-        it "is an array" do
-          expect(subject).to be_an Array
-        end
-
-        describe "first suggestion" do
-          describe "#terms" do
-            it "is an Array" do
-              expect(subject.first.terms).to be_an Array
-            end
-
-            it "counts one" do
-              expect(subject.first.terms.count).to eq 1
-            end
-
-            describe "first term" do
-              describe "#text" do
-                it "equals 'ba'" do
-                  expect(subject.first.terms.first.text).to eq "ba"
-                end
-
-                describe "#options" do
-                  it "includes the options" do
-                    expect(subject.first.terms.first.options).to include({
-                      text: "bar",
-                      score: 1.0
-                    })
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/responses/validation_response_spec.rb

@@ -1,45 +0,0 @@
-require "spec_helper"
-
-module ElasticAdapter
-  module Responses
-    describe ValidationResponse do
-      let(:response) {{
-        valid: false,
-        shards: {
-          total: 1,
-          successful: 1,
-          failed: 0
-        },
-        explanations: [ 
-          {
-            index: "twitter",
-            valid: false,
-            error: "some error message"
-          }
-        ]
-      }}
-
-      subject { ValidationResponse.new(response) }
-
-      describe "#valid?" do
-        it "returns false" do
-          expect(subject.valid?).to be false
-        end
-      end
-
-      describe "#explanations" do
-        it "is an Array" do
-          expect(subject.explanations).to be_an Array
-        end
-
-        it "includes the explanation" do
-          expect(subject.explanations).to include({
-            index: "twitter",
-            valid: false,
-            error: "some error message"
-          })
-        end
-      end
-    end
-  end
-end