elastic_adapter 0.0.1

data/spec/index_spec.rb

@@ -0,0 +1,458 @@
+require "spec_helper"
+
+RSpec.shared_examples "response without exception" do
+  it "is a Response" do
+    expect(response).to be_a ElasticAdapter::Response
+  end
+
+  it "has no exception" do
+    expect(response).not_to have_key :exception
+  end
+end
+
+RSpec.shared_examples "response with exception" do
+  it "is a Response" do
+    expect(response).to be_a ElasticAdapter::Response
+  end
+
+  it "has an exception" do
+    expect(response).to have_key :exception
+  end
+end
+
+module ElasticAdapter
+  describe Index, :vcr do
+    def test_index(name = "test_index", options = {})
+      params = {
+        name: name,
+        url: "http://localhost:9200",
+        log: true,
+        settings: {},
+        document_type: OpenStruct.new(
+          name: "test_doc",
+          mappings: {
+            test_doc: {
+              properties: {
+                foo: { type: "string" }
+              }
+            }
+          }
+        )
+      }.merge(options)
+
+      Index.new(params)
+    end
+
+    def create_test_index(name = "test_index", options = {})
+      test_index(name, options).create_index
+    end
+
+    def delete_test_index(name = "test_index", options = {})
+      test_index(name, options).delete_index
+    end
+
+    def index_document(document, name = "test_index", options = {})
+      test_index(name, options).index(document)
+    end
+
+    def wait_for_elasticsearch
+      if ENV["RECORDING"]
+        sleep 1
+      end
+    end
+
+    let(:name) { "test_index" }
+    let(:mappings) do
+      {
+        test_index: {
+          properties: {
+            foo: {
+              type: "string"
+            }
+          }
+        }
+      }
+    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(:subject) do
+      Index.new(
+        name: name,
+        settings: settings,
+        document_type: document_type,
+        url: url,
+        log: log
+      )
+    end
+
+    describe "#initialize" do
+      it "assigns the name" do
+        expect(subject.instance_variable_get('@name')).to be name
+      end
+
+      it "assigns the settings" do
+        expect(subject.instance_variable_get('@settings')).to be settings
+      end
+
+      it "assigns the document_type" do
+        expect(subject.instance_variable_get('@document_type')).to be document_type
+      end
+
+      it "assigns the url" do
+        expect(subject.instance_variable_get('@url')).to be url
+      end
+
+      it "assigns the log" do
+        expect(subject.instance_variable_get('@log')).to be log
+      end
+    end
+
+    describe "getter" do
+      describe "name" do
+        it "returns the name" do
+          expect(subject.name).to eq name
+        end
+      end
+
+      describe "settings" do
+        it "returns the settings" do
+          expect(subject.settings).to eq settings
+        end
+      end
+
+      describe "document_type" do
+        it "returns the document_type" do
+          expect(subject.document_type).to eq document_type
+        end
+      end
+
+      describe "url" do
+        it "returns the url" do
+          expect(subject.url).to eq url
+        end
+      end
+
+      describe "log" do
+        it "returns the log" do
+          expect(subject.log).to eq log
+        end
+      end
+
+      describe "client" do
+        it "returns the client" do
+          expect(subject.client).to be_a ::Elasticsearch::Transport::Client
+        end
+      end
+    end
+
+    describe "#validate" do
+      before :all do
+        create_test_index
+        wait_for_elasticsearch
+      end
+
+      after :all do
+        delete_test_index
+      end
+
+      context "invalid query" do
+        let(:query) do
+          {
+            asd: "[[[ BOOM! ]]]"
+          }
+        end
+
+        let(:response) { subject.validate(query) }
+
+        it "is false" do
+          expect(response).to eq false
+        end
+
+        it "is a response" do
+          expect(response).to be_a Decoration::ValidationResponse
+        end
+      end
+
+      context "valid query" do
+        let(:query) do
+          {
+            query: {
+              match_all: {}
+            }
+          }
+        end
+
+        let(:response) { subject.validate(query) }
+
+        it "is true" do
+          expect(response).to eq true
+        end
+
+        it "is a response" do
+          expect(response).to be_a Decoration::ValidationResponse
+        end
+      end
+    end
+
+    describe "#suggest" do
+      before :all do
+        create_test_index "test_index", document_type: OpenStruct.new(
+          name: "test_doc",
+          mappings: {
+            test_doc: {
+              properties: {
+                foo: { type: "completion" }
+              }
+            }
+          }
+        )
+
+        index_document(foo: {input: "bar"})
+        index_document(foo: {input: "zoo"})
+        sleep 1
+      end
+
+      after :all do
+        delete_test_index
+      end
+
+      context "query 'ba'" do
+        let(:query) do
+          {
+            foo_suggest: {
+              text: "ba",
+              completion: {
+                field: "foo"
+              }
+            }
+          }
+        end
+
+        let(:response) { subject.suggest(query)}
+
+        it "returns one result" do
+          expect(response.count).to eq 1
+        end
+
+        it "returns bar" do
+          expect(response[:options].first).to include text: "bar"
+        end
+
+      end
+    end
+
+    describe "#search" do
+      before :all do
+        create_test_index
+        index_document(foo: "bar", id: 1)
+        index_document(foo: "zoo", id: 2)
+        sleep 1
+      end
+
+      after :all do
+        delete_test_index
+      end
+
+      context "match_all" do
+        it "returns all documents" do
+          expect(subject.search({query: {match_all: {}}}).count).to eq 2
+        end
+      end
+
+      context "zoo" do
+        let(:response) { subject.search(query: {match: {foo: "zoo"}})}
+        it "returns one document" do
+          expect(response.count).to eq 1
+        end
+
+        it "returns the wanted document" do
+          expect(response[:hits].first[:id]).to eq "2"
+          expect(response[:hits].first[:foo]).to eq "zoo"
+        end
+      end
+    end
+
+    describe "#get" do
+      context "document exists" do
+        let(:document) { {id: "1", foo: "bar"} }
+        before :all do
+          create_test_index
+          index_document(foo: "bar", id: 1)
+        end
+
+        after :all do
+          delete_test_index
+        end
+
+        let(:response) { subject.get(1) }
+
+        describe "response" do
+          it "contains the document" do
+            expect(response).to eq document
+          end
+        end
+      end
+    end
+
+    describe "#index" do
+      context "new document" do
+        let(:document) { { foo: "bar" } }
+
+        before :all do
+          create_test_index
+        end
+
+        after :all do
+          delete_test_index
+        end
+
+        it "indexes a document" do
+          subject.index(document)
+          # wait_for_elasticsearch
+          sleep 1
+          expect(subject.count).to eq 1
+        end
+
+        it "invokes to_hash on the document" do
+          expect(document).to receive(:to_hash).and_return(document.to_hash)
+          subject.index(document)
+        end
+      end
+
+      context "existing document" do
+        let(:document) { {foo: "baz", id: 1} }
+
+        before :all do
+          create_test_index
+          # wait_for_elasticsearch
+          sleep 1
+          index_document foo: "bar", id: 1
+          # wait_for_elasticsearch
+          sleep 1
+        end
+
+        after :all do
+          delete_test_index
+        end
+
+        it "doesn't change the document count" do
+          expect(subject.count).to eq 1
+          subject.index(document)
+          sleep 1
+          # wait_for_elasticsearch
+          expect(subject.count).to eq 1
+        end
+
+        it "invokes to_hash on the document" do
+          expect(document).to receive(:to_hash).and_return(document.to_hash)
+          subject.index(document)
+        end
+
+        it "updates the document" do
+          expect(subject.get(1)[:foo]).to eq "baz"
+        end
+      end
+    end
+
+    describe "#count" do
+      context "empty index" do
+        before :all do
+          create_test_index
+          wait_for_elasticsearch
+        end
+
+        after :all do
+          delete_test_index
+        end
+
+        it "returs the amount of all documents" do
+          expect(subject.count).to eq 0
+        end
+
+        it "is a response" do
+          expect(subject.count).to be_a Decoration::CountResponse
+        end
+      end
+
+      context "not empty index" do
+        before :all do
+          create_test_index
+          index_document foo: "bar"
+          sleep 1
+          # wait_for_elasticsearch
+        end
+
+        after :all do
+          delete_test_index
+        end
+
+        it "returns 1" do
+          expect(subject.count).to eq 1
+        end
+
+        it "is a response" do
+          expect(subject.count).to be_a Decoration::CountResponse
+        end
+      end
+    end
+
+    describe "#delete_index" do
+      context "index present" do
+        before :each do
+          create_test_index
+        end
+
+        let(:response) { subject.delete_index }
+
+        describe "repsonse" do
+          include_examples "response without exception"
+        end
+      end
+
+      context "index not present" do
+        let(:response) { subject.delete_index }
+
+        describe "repsonse" do
+          include_examples "response with exception"
+        end
+      end
+    end
+
+    describe "#create_index" do
+      context "index is present" do
+        before :all do
+          create_test_index
+        end
+
+        after :all do
+          delete_test_index
+        end
+
+        let(:response) { subject.create_index }
+
+        describe "response" do
+          # TODO fix this
+          # Somehow VCR doesn't record the requests for the current context
+          include_examples "response with exception"
+        end
+      end
+
+      context "index not present" do
+        after :each do
+          delete_test_index
+        end
+
+        let(:response) { subject.create_index }
+
+        describe "response" do
+          include_examples "response without exception"
+        end
+      end
+    end
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+module ElasticAdapter
+  describe Response do
+    describe "delegation" do
+      let(:hash) { { foo: "bar" } }
+      let(:response) { Response.new(hash) }
+
+      describe "#original_object" do
+        it "returns the original hash" do
+          expect(response.original_object).to be hash
+        end
+      end
+
+      describe "object" do
+        it "returns the sanitized hash" do
+          expect(response.object).to eq({ foo: "bar" })
+        end
+      end
+    end
+
+    describe "sanitization" do
+      it "turns all strings in Hash keys to symbols" do
+        hash = {"foo" => "bar"}
+        response = Response.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 = Response.new(hash)
+        expect(response.object).to eq expected
+      end
+    end
+
+    describe "#failure?" do
+      context "no exception" do
+        let(:hash) { { foo: "bar" } }
+        let(:response) { Response.new(hash) }
+
+        it "returns false" do
+          expect(response.failure?).to be false
+        end
+      end
+
+      context "with exception" do
+        let(:hash) { { foo: "bar", exception: ArgumentError.new("foo") } }
+        let(:response) { Response.new(hash) }
+
+        it "returns true" do
+          expect(response.failure?).to be true
+        end
+      end
+    end
+
+    describe "#decorate" do
+      context "find request" do
+        let(:document) { {foo: "bar", id: 1} }
+        let(:response_hash) do
+          {
+            "found" => true,
+            "_id" => 1,
+            "_source" => {
+              "foo" => "bar"
+            }
+          }
+        end
+
+        let(:response) do
+          response = Response.new(response_hash)
+        end
+
+        it "is the document" do
+          expect(response.decorate.to_hash).to eq document
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,102 @@
+require "elastic_adapter"
+require "rake"
+require "webmock/rspec"
+require "vcr"
+
+VCR.configure do |config|
+  config.cassette_library_dir = 'spec/cassettes'
+  config.hook_into :webmock
+  config.default_cassette_options = { record: :new_episodes }
+  config.configure_rspec_metadata!
+  config.allow_http_connections_when_no_cassette = true
+end
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end