elastic_adapter 0.0.8 → 0.1.0

data/spec/unit/index_spec.rb

@@ -0,0 +1,218 @@
+require "spec_helper"
+
+module ElasticAdapter
+  describe Index do
+    let(:name) { "test_index" }
+    let(:mappings) do
+      {
+        test_index: {
+          properties: {
+            foo: {
+              type: "string",
+              foo_suggest: { type: "completion" }
+            }
+          }
+        }
+      }
+    end
+    let(:document_type) do
+      OpenStruct.new(name: "test_doc", mappings: mappings)
+    end
+    let(:settings) { { number_of_shards: 1 } }
+    let(:log) { true }
+    let(:url) { "http://localhost:9200"}
+    let(:indices) { double("indices") }
+    let(:client) { double("client") }
+
+    subject do
+      ElasticAdapter::Index.new(
+        name: name,
+        settings: settings,
+        document_type: document_type,
+        url: url,
+        log: log,
+        client: client
+      )
+    end
+
+    before do
+      allow(client).to receive(:indices).and_return(indices)
+    end
+
+    let(:query) {{ query: { match_all: {} } }}
+
+    describe "#initialize" do
+      it "takes a hash as arguments" do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    describe "#name" do
+      it "returns the name" do
+        expect(subject.name).to be name
+      end
+    end
+
+    describe "#settings" do
+      it "returns the settings" do
+        expect(subject.settings).to be settings
+      end
+    end
+
+    describe "#document_type" do
+      it "returns the document type" do
+        expect(subject.document_type).to be document_type
+      end
+    end
+
+    describe "#url" do
+      it "returns the url" do
+        expect(subject.url).to be url
+      end
+    end
+
+    describe "#log" do
+      it "returns log" do
+        expect(subject.log).to be log
+      end
+    end
+
+    describe "client" do
+      it "returns a client" do
+        expect(subject.client).to be client
+      end
+    end
+
+    describe "#create_index" do
+      it "creates the index" do
+        expect(indices).to receive(:create)
+          .with(
+            index: name,
+            body: { 
+              mappings: document_type.mappings,
+              settings: settings
+            }
+          )
+        subject.create_index
+      end
+    end
+
+    describe "#delete_index" do
+      it "deletes the index" do
+        expect(indices).to receive(:delete).with(index: name)
+        subject.delete_index
+      end
+    end
+
+    describe "#count" do
+      it "does a count request" do
+        expect(client).to receive(:count).with(index: name, body: query)
+        subject.count(query)
+      end
+
+      it "returns a response with count" do
+        expect(client).to receive(:count).and_return({})
+        expect(subject.count(query).singleton_class).to be < Responses::WithCount
+      end
+    end
+
+    describe "#index" do
+      let(:doc) {{ id: 1, foo: "bar" }}
+
+      it "indexes the document" do
+        expect(client).to receive(:index)
+          .with(
+            index: name,
+            id: 1,
+            type: document_type.name,
+            body: { foo: "bar" }
+          )
+        subject.index(doc)
+      end
+
+      it "returns a response" do
+        expect(client).to receive(:index).and_return({})
+        result = subject.index(doc)
+        expect(result).to be_a Response
+      end
+    end
+
+    describe "#get" do
+      it "does a get request" do
+        expect(client).to receive(:get).with(index: name, type: document_type.name, id: 1)
+        subject.get(1)
+      end
+
+      it "returns a response with hit" do
+        expect(client).to receive(:get).and_return({})
+        result = subject.get(1)
+        expect(result.singleton_class).to be < Responses::WithHit
+      end
+    end
+
+    describe "#search" do
+      it "does a search request" do
+        expect(client).to receive(:search).with(index: name, body: query)
+        subject.search(query)
+      end
+
+      it "returns a response with hits, aggregations and suggestions" do
+        expect(client).to receive(:search).and_return({})
+        result = subject.search(query)
+        expect(result.singleton_class).to be < Responses::WithHits
+        expect(result.singleton_class).to be < Responses::WithSuggestions
+        expect(result.singleton_class).to be < Responses::WithAggregations
+      end
+    end
+
+    describe "#suggest" do
+      it "does a suggest request" do
+        expect(client).to receive(:suggest).with(index: name, body: query)
+        subject.suggest(query)
+      end
+
+      it "returns a response with suggestions" do
+        expect(client).to receive(:suggest).and_return({})
+        result = subject.suggest(query)
+        expect(result.singleton_class).to be < Responses::WithSuggestions
+      end
+    end
+
+    describe "#aggregate" do
+      it "does a aggregate request" do
+        expect(client).to receive(:search).with(index: name, body: query)
+        subject.aggregate(query)
+      end
+
+      it "returns a response with aggregations" do
+        expect(client).to receive(:search).and_return({})
+        result = subject.aggregate(query)
+        expect(result.singleton_class).to be < Responses::WithAggregations
+      end
+    end
+
+    describe "#validate" do
+      it "does a validate request" do
+        expect(indices).to receive(:validate_query).with(index: name, body: query, explain: true)
+        subject.validate(query)
+      end
+
+      it "returns a response with validations" do
+        expect(indices).to receive(:validate_query).and_return({})
+        result = subject.validate(query)
+        expect(result.singleton_class).to be < Responses::WithValidations
+      end
+    end
+
+    describe "error handling" do
+      before do
+        allow(client).to receive(:search).and_raise(Elasticsearch::Transport::Transport::Error)
+      end
+
+      it "returns a response with exception" do
+        result = subject.search(query)
+        expect(result.singleton_class).to be < Responses::WithException
+      end
+    end
+  end
+end

data/spec/unit/response_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+module ElasticAdapter
+  describe Response do
+    let(:object) {{
+      "foo" => { "bim" => "bam" },
+      "bar" => [
+        { "biz" => "buz" }
+      ],
+      "boo" => "bam"
+    }}
+
+    subject { Response.new(object) }
+
+    describe "symbolize keys" do
+      it "symbolizes all keys" do
+        expected = {
+          foo: { bim: "bam" },
+          bar: [
+            { biz: "buz" }
+          ],
+          boo: "bam"
+        }
+        expect(subject.object).to eq expected
+      end
+    end
+  end
+end

data/spec/unit/responses/with_aggregations_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+module ElasticAdapter
+  describe Responses::WithAggregations do
+    let(:plain_response) {{
+      aggregations: {
+        products: {
+          doc_count_error_upper_bound: 46,
+          buckets: [
+            {
+              key: "Product A",
+              doc_count: 100
+            },
+            {
+              key: "Product Z",
+              doc_count: 52
+            }
+          ]
+        }
+      }
+    }}
+    subject { Response.new(plain_response).extend(Responses::WithAggregations) }
+
+    describe "#aggregations" do
+      it "includes the products aggregation" do
+        expect(subject.aggregations).to eq plain_response[:aggregations]
+      end
+    end
+  end
+end

data/spec/unit/responses/with_count_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+module ElasticAdapter
+  describe Responses::WithCount do
+    let(:plain_response) {{
+      count: 1,
+      shards: {
+        total: 5,
+        successful: 5,
+        failed: 0
+      }
+    }}
+
+    subject { Response.new(plain_response).extend(Responses::WithCount) }
+
+    describe "#count" do
+      it "returns the count" do
+        expect(subject.count).to eq 1
+      end
+    end
+  end
+end

data/spec/unit/responses/with_exception_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+module ElasticAdapter
+  describe Responses::WithException do
+    let(:plain_response) {{
+      exception: ArgumentError.new()
+    }}
+
+    subject { Response.new(plain_response).extend(Responses::WithException) }
+
+    describe "#exception" do
+      it "returns the exception" do
+        expect(subject.exception).to be plain_response[:exception]
+      end
+    end
+  end
+end

data/spec/unit/responses/with_hit_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+module ElasticAdapter
+  describe Responses::WithHits do
+    let(:plain_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 { Response.new(plain_response).extend(Responses::WithHit) }
+
+    describe "#hit" do
+      it "is the hit" do
+        doc = {
+          index: "twitter",
+          type: "tweet",
+          id: "1",
+          source: {
+            user: "kimchy",
+            postDate: "2009-11-15T14:12:12",
+            message: "trying out Elasticsearch"
+          }
+        }
+
+        expect(subject.hit).to eq doc
+
+      end
+
+      describe "#found?" do
+        it "returns true" do
+          expect(subject.hit.found?).to be true
+        end
+      end
+
+      describe "#found" do
+        it "returns the version" do
+          expect(subject.hit.version).to eq 1
+        end
+      end
+    end
+  end
+end

data/spec/unit/responses/with_hits_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+module ElasticAdapter
+  describe Responses::WithHits do
+    context "with hits" do
+      let(:plain_response) {{
+        shards: {
+          total: 5,
+          successful: 5,
+          failed: 0
+        },
+        hits: {
+          total: 100,
+          hits: [
+            {
+              index: "twitter",
+              type: "tweet",
+              id: "1",
+              source: {
+                user: "kimchy",
+                postDate: "2009-11-15T14:12:12",
+                message: "trying out Elasticsearch"
+              }
+            }
+          ]
+        }
+      }}
+
+      subject { Response.new(plain_response).extend(Responses::WithHits) }
+
+      describe "#hits" do
+        it "includes the hit in a flattened format" do
+          doc = {
+            index: "twitter",
+            type: "tweet",
+            id: "1",
+            source: {
+              user: "kimchy",
+              postDate: "2009-11-15T14:12:12",
+              message: "trying out Elasticsearch"
+            }
+          }
+
+          expect(subject.hits).to include doc
+        end
+
+        describe "#count" do
+          it "returns the count" do
+            expect(subject.hits.count).to be plain_response[:hits][:total]
+          end
+        end
+      end
+    end
+
+    context "without hits" do
+      let(:plain_response) {{
+        shards: {
+          total: 5,
+          successful: 5,
+          failed: 0
+        },
+        hits: {
+          total: 0,
+          hits: []
+        }
+      }}
+
+      subject { Response.new(plain_response).extend(Responses::WithHits) }
+
+      describe "#hits" do
+        describe "#count" do
+          it "returns 0" do
+            expect(subject.hits.count).to eq 0
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/responses/with_suggestions_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+module ElasticAdapter
+  describe Responses::WithSuggestions do
+    let(:plain_response) {{
+      shards: {
+          total: 5, successful: 5, failed: 0
+      },
+      suggest: {
+        foo_suggest: [
+          {
+            text: "ba",
+            offset: 0,
+            length: 2,
+            options: [
+              {
+                text: "bar",
+                score: 1.0
+              }
+            ]
+          }
+        ]
+      }
+    }}
+    subject { Response.new(plain_response).extend(Responses::WithSuggestions) }
+
+    describe "#suggestions" do
+      it "includes the suggestion" do
+        expect(subject.suggestions).to eq plain_response[:suggest]
+      end
+    end
+  end
+end

data/spec/unit/responses/with_validations_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+module ElasticAdapter
+  describe Responses::WithValidations do
+    let(:plain_response) {{
+      valid: false,
+      shards: {
+        total: 1,
+        successful: 1,
+        failed: 0
+      },
+      explanations: [ 
+        {
+          index: "twitter",
+          valid: false,
+          error: "some error message"
+        }
+      ]
+    }}
+    subject { Response.new(plain_response).extend(Responses::WithValidations) }
+
+    describe "#explanations" do
+      it "includes the explanation" do
+        expect(subject.explanations).to eq plain_response[:explanations]
+      end
+    end
+
+    describe "#valid?" do
+      it "returns false" do
+        expect(subject.valid?).to be false
+      end
+    end
+  end
+end