esearch 0.2.0

data/lib/esearch/presenter/status.rb

@@ -0,0 +1,18 @@
+module Esearch
+  class Presenter
+
+    # Status presenter base class
+    class Status < self
+
+      # Status of an elasticsearch index
+      class Index < Presenter
+
+        expose_primitive('name')
+
+      end
+
+      expose_tagged_collection('indices', Status::Index)
+
+    end
+  end
+end

data/lib/esearch/request.rb

@@ -0,0 +1,90 @@
+module Esearch
+
+  # Request used to interface elasticsearch
+  class Request
+    include Adamantium, Equalizer.new(:verb, :path, :body, :params)
+
+    EMPTY_HASH = {}.freeze
+
+    # Return http verb
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    #
+    attr_reader :verb
+
+    # Return path
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    attr_reader :path
+
+    # Return body
+    #
+    # @return [Hash]
+    #
+    # @api private
+    #
+    attr_reader :body
+
+    # Return params
+    #
+    # @return [Hash]
+    #
+    # @api private
+    #
+    attr_reader :params
+
+    # Initialize object
+    #
+    # @param [Symbol] verb
+    # @param [String] path
+    # @param [Hash] body
+    # @param [Hash] params
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(verb, path, body = EMPTY_HASH, params = EMPTY_HASH)
+      @verb, @path, @body, @params = verb, path.to_s, body, params
+    end
+
+    # Return log string
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def log_string
+      "#{verb.upcase} #{path} : #{params} : #{body}"
+    end
+    memoize :log_string
+
+    # Run request on connection
+    #
+    # @param [Faraday::Connection]
+    #
+    # @return [Faraday::Response]
+    #
+    # @api private
+    #
+    def run(connection)
+      connection.public_send(verb, path) do |request|
+        request.params = params
+        request.headers[:content_type]=Command::JSON_CONTENT_TYPE
+        request.body = MultiJson.dump(body)
+      end
+    end
+
+    [:head, :get, :post, :put, :delete].each do |verb|
+      define_singleton_method(verb) do |*args|
+        new(verb, *args)
+      end
+    end
+
+  end
+end

data/lib/esearch/type.rb

@@ -0,0 +1,40 @@
+module Esearch
+  # Interface to a specific elasticsearch type
+  class Type
+    include Adamantium::Flat, Concord.new(:es_index, :name)
+    include Mixin::Exist, Mixin::Document, Mixin::Search
+
+    # Return document handler
+    #
+    # @param [String] id
+    #
+    # @return [Document]
+    #
+    # @api private
+    #
+    def document(id)
+      Document.new(self, id)
+    end
+
+    # Return connection
+    #
+    # @return [Faraday::Connection]
+    #
+    # @api private
+    #
+    def connection
+      es_index.connection
+    end
+
+    # Return path
+    #
+    # @return [Pathname]
+    #
+    # @api private
+    #
+    def path
+      es_index.path.join(name)
+    end
+    memoize :path
+  end
+end

data/spec/integration/esearch/spike_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'logger'
+
+describe Esearch do
+  let(:uri) { ENV.fetch('ESEARCH_TEST_URI', 'http://localhost:9200') }
+
+  SINGLE_NODE_SETTINGS = IceNine.deep_freeze(
+    :settings => {
+      :number_of_shards => 1,
+      :number_of_replicas => 0
+    }
+  )
+
+  let(:cluster) { Esearch::Cluster.connect(uri, Logger.new($stderr, :debug)) }
+
+  it 'should work' do
+    cluster.all_indices.status.indices.map do |index|
+      cluster.index(index.name).delete
+    end
+
+    index_a = cluster.index('test-a')
+    index_a.exist?.should be(false)
+    index_a.create(SINGLE_NODE_SETTINGS)
+    index_a.exist?.should be(true)
+
+    index_b = cluster.index('test-b')
+    index_b.create(SINGLE_NODE_SETTINGS)
+
+    indices = cluster.indices(%w(test-a test-b))
+
+    result_a = index_a.type('type-a').index({'foo' => 'bar'})
+    result_b = index_b.type('type-b').index({'foo' => 'baz'})
+
+    cluster.health(:wait_for_status => :green, :timeout => '10s')
+
+    indices.refresh
+
+    result = index_a.search({:query => { :match_all => {}}})
+    result.hits.map(&:source).should eql([{'foo' => 'bar'}])
+
+    result = indices.search({:query => { :match_all => {}}})
+
+    result.hits.map(&:source).to_set.should eql([{'foo' => 'bar'}, {'foo' => 'baz'}].to_set)
+
+    index_a.type('type-a').document(result_a.id).delete
+
+    document = index_b.type('type-b').document(result_b.id).get
+    document.source.should eql('foo' => 'baz')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require 'esearch'
+require 'devtools'
+Devtools.init_spec_helper
+
+module CommandHelper
+  module ClassMethods
+
+    def expect_to_run_command(command)
+      let(:connection) { mock('Connection') }
+      let(:result)     { mock('Result')     }
+
+      before do
+        command.should_receive(:run).with(object, *expected_arguments).and_return(result)
+      end
+
+      it { should be(result) }
+    end
+
+    def setup_connection
+      let(:context)    { mock('Context', :connection => connection, :path => Pathname.new('/foo')) }
+      let(:connection) { mock('Connection')                                                        }
+
+      let(:headers)    { {'content-type' => 'application/json; charset=UTF-8'} }
+      let(:response)   { mock('Response', :frozen? => true, :status => status, :headers => headers, :body => '{}') }
+
+      let(:status)     { 200 }
+
+      before do
+        connection.should_receive(:run).with(expected_request).and_return(response)
+      end
+    end
+
+    def expect_exception(exception)
+      setup_connection
+      
+      yield if block_given?
+
+      it 'should raise error' do
+        expect { subject }.to raise_error(exception)
+      end
+    end
+
+    def expect_result(result)
+      setup_connection
+
+      yield if block_given?
+
+      it { should eql(result) }
+    end
+
+    def expect_presenter(presenter, &block) 
+      expect_result(presenter.new({}), &block)
+    end
+  end
+
+  def self.included(descendant)
+    descendant.extend(ClassMethods)
+  end
+end
+
+
+RSpec.configure do |config|
+  config.include(CommandHelper)
+end

data/spec/support/example_group_methods.rb

@@ -0,0 +1,7 @@
+module Spec
+  module ExampleGroupMethods
+    def testing_block_passing_broken?
+      RUBY_PLATFORM.include?('java') && JRUBY_VERSION <= '1.7.0.dev' && RUBY_VERSION >= '1.9.2'
+    end
+  end
+end

data/spec/support/ice_nine_config.rb

@@ -0,0 +1,6 @@
+module IceNine
+  class Freezer
+    class RSpec < NoFreeze
+    end
+  end
+end

data/spec/unit/esearch/cluster/class_methods/connect_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Esearch::Cluster, '.connect' do
+  subject { object.connect(*arguments) }
+
+  let(:object)     { described_class    }
+  let(:connection) { mock('Connection') }
+
+  let(:arguments) { [:foo, :bar] }
+  
+  before do
+    Esearch::Connection.should_receive(:build).with(:foo, :bar).and_return(connection)
+  end
+
+  it { should eql(described_class.new(connection)) }
+end

data/spec/unit/esearch/cluster/health_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Esearch::Cluster, '#health' do
+  subject { object.health }
+
+  let(:object)     { described_class.new(connection) }
+  let(:expected_arguments) { [{}] }
+
+  expect_to_run_command(Esearch::Command::Cluster::Health)
+end

data/spec/unit/esearch/cluster/index_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Esearch::Cluster, '#index' do
+  subject { object.index(name) }
+
+  let(:object)     { described_class.new(connection) }
+  let(:connection) { mock('Connection')              }
+  let(:name)       { 'foo'                           }
+
+  it { should eql(Esearch::Index.new(connection, name)) }
+end

data/spec/unit/esearch/cluster/indices_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Esearch::Cluster, '#indices' do
+  subject { object.indices(names) }
+
+  let(:object)     { described_class.new(connection) }
+  let(:connection) { mock('Connection')              }
+  let(:names)      { %w(foo bar)                     }
+
+  it { should eql(Esearch::Indices.new(connection, names)) }
+end

data/spec/unit/esearch/cluster/path_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Esearch::Cluster, '#path' do
+  subject { object.path }
+
+  let(:object) { described_class.new(connection) }
+
+  let(:connection) { mock('Connection') }
+
+  it { should eql(Pathname.new('/')) }
+end

data/spec/unit/esearch/command/class_methods/run_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Esearch::Command, '.run' do
+  subject { object.run(*arguments) }
+
+  let(:object) { described_class }
+
+  let(:instance)  { mock('Instance', :result => result) }
+  let(:result)    { mock('Result')                      }
+  let(:arguments) { [:foo, :bar]                        }
+
+  it 'should instantiate object and return result' do
+    described_class.should_receive(:new).with(*arguments).and_return(instance)
+    should be(result)
+  end
+end

data/spec/unit/esearch/command/cluster/health/run_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Esearch::Command::Cluster::Health, '.run' do
+  subject { object.run(context, options) }
+
+  let(:object)   { described_class  }
+  let(:options)  { mock('Options')  }
+
+  let(:expected_request) do
+    Esearch::Request.new(:get, '/_cluster/health', {}, options)
+  end
+ 
+  expect_presenter(Esearch::Presenter::Cluster::Health)
+end

data/spec/unit/esearch/command/document/delete/run_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Esearch::Command::Document::Delete, '.run' do
+  subject { object.run(context) }
+
+  let(:object)   { described_class  }
+
+  let(:expected_request) do
+    Esearch::Request.new(:delete, '/foo', {}, {})
+  end
+ 
+  expect_presenter(Esearch::Presenter::Document::Operation::Delete)
+end

data/spec/unit/esearch/command/document/get/result_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Esearch::Command::Document::Get, '.run' do
+  subject { object.run(context) }
+
+  let(:object)   { described_class  }
+
+  let(:expected_request) do
+    Esearch::Request.new(:get, '/foo', {}, {})
+  end
+ 
+  context 'with status 200' do
+    expect_presenter(Esearch::Presenter::Document::Get)
+  end
+ 
+  context 'with status 404' do
+    expect_result(nil) do
+      let(:status) { 404 }
+    end
+  end
+ 
+  context 'with status 500' do
+    expect_exception(Esearch::ProtocolError) do
+      let(:status) { 500 }
+    end
+  end
+end

data/spec/unit/esearch/command/document/index/create/run_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Esearch::Command::Document::Index::Create, '.run' do
+  subject { object.run(context, document, options) }
+
+  let(:object)   { described_class  }
+  let(:document) { mock('Document') }
+  let(:options)  { { :foo => :bar } }
+
+  let(:expected_request) do
+    Esearch::Request.new(:post, '/foo', document, { :foo => :bar, :op_type => :create })
+  end
+ 
+  expect_presenter(Esearch::Presenter::Document::Operation::Index) do
+    let(:status) { 201 }
+  end
+end