esearch 0.2.0

data/spec/unit/esearch/command/document/index/run_create_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

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Esearch::Command::Document::Index, '.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, options)
+  end
+
+  expect_presenter(Esearch::Presenter::Document::Operation::Index)
+end

data/spec/unit/esearch/command/document/index/run_update_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Esearch::Command::Document::Index::Update, '.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 => :index })
+  end
+
+  expect_presenter(Esearch::Presenter::Document::Operation::Index)
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Esearch::Command::Document::Index::Update, '.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 => :index })
+  end
+
+  expect_presenter(Esearch::Presenter::Document::Operation::Index)
+end

data/spec/unit/esearch/command/exist/result_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Esearch::Command::Exist, '.run' do
+  subject { object.run(context) }
+
+  let(:object)   { described_class  }
+
+  let(:expected_request) do
+    Esearch::Request.new(:head, '/foo', {}, {})
+  end
+
+  before do
+    connection.should_receive(:run).with(expected_request).and_return(response)
+  end
+
+  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 => '{}') }
+
+  context 'with status 200' do
+    let(:status)     { 200 }
+    it { should be(true) }
+  end
+
+  context 'with status 404' do
+    let(:status)     { 404 }
+    it { should be(false) }
+  end
+
+  context 'with other status' do
+    let(:status) { 500 }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Esearch::Command::Index::Create, '.run' do
+  subject { object.run(context, settings) }
+
+  let(:object)   { described_class  }
+  let(:settings) { mock('Settings') }
+
+  let(:expected_request) do
+    Esearch::Request.new(:put, '/foo', settings, {})
+  end
+ 
+  expect_presenter(Esearch::Presenter::Index::Create)
+end

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

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Esearch::Command::Index::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::Index::Delete)
+end

data/spec/unit/esearch/command/index/refresh/run_spec.rb

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

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

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Esearch::Command, '#result' do
+  let(:object) { class_under_test.new(context) }
+
+  subject { object.result }
+
+  class DummyPresenter
+    include Concord.new(:raw)
+  end
+
+  let(:class_under_test) do
+    Class.new(described_class) do
+      const_set('PRESENTER', DummyPresenter)
+      def request
+        Esearch::Request.new(:get, context_path)
+      end
+    end
+  end
+
+
+  let(:context)    { mock('Context', :connection => connection, :path => Pathname.new('/foo')) }
+  let(:connection) { mock('Connection')                                                        }
+
+  let(:headers)    { {'content-type' => content_type } }
+  let(:content_type) { 'application/json; charset=UTF-8' }
+  let(:response)   { mock('Response', :frozen? => true, :status => status, :headers => headers, :body => body) }
+  let(:body)       { '{}' }
+
+  let(:status)     { 200 }
+
+  let(:expected_request) do
+    Esearch::Request.new(:get, context.path)
+  end
+
+  before do
+    connection.should_receive(:run).with(expected_request).and_return(response)
+  end
+
+  it { should eql(DummyPresenter.new({})) }
+
+  context 'when content type is not expected' do
+    let(:content_type) { 'text/plain' }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(Esearch::ProtocolError, 'Expected json content type, but got: "text/plain"')
+    end
+  end
+
+  context 'when status code is not expected' do
+    let(:status) { 201 }
+
+    context 'with json body' do
+      it 'should raise error' do
+        expect { subject }.to raise_error(Esearch::ProtocolError, 'expected response stati: [200] but got: 201, remote message: {}')
+      end
+    end
+
+    context 'with other body' do
+      let(:content_type) { 'text/plain' }
+      let(:body)         { 'message'   }
+
+      it 'should raise error' do
+        expect { subject }.to raise_error(Esearch::ProtocolError, 'expected response stati: [200] but got: 201, remote message: "message"')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Esearch::Command::Search, '.run' do
+  subject { object.run(context, query) }
+
+  let(:object) { described_class }
+  let(:query)  { mock('Query') }
+
+  let(:expected_request) do
+    Esearch::Request.new(:get, '/foo/_search', query, {})
+  end
+
+  expect_presenter(Esearch::Presenter::Search)
+end

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

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

data/spec/unit/esearch/connection/class_methods/build_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Esearch::Connection, '.build' do
+  let(:object) { described_class }
+
+  subject { object.build(*arguments) }
+
+  let(:url)        { mock('URL')        }
+  let(:logger)     { mock('Logger')     }
+  let(:connection) { mock('Connection') }
+
+  before do
+    Faraday.should_receive(:new).with(url).and_return(connection)
+  end
+
+  context 'with one argument' do
+    let(:arguments) { [url] }
+
+    its(:raw_connection) { should be(connection)          }
+    its(:logger)         { should be(NullLogger.instance) }
+  end
+
+  context 'with twi arguments' do
+    let(:arguments) { [url, logger] }
+
+    its(:raw_connection) { should be(connection) }
+    its(:logger)         { should be(logger)     }
+  end
+end

data/spec/unit/esearch/connection/run_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Esearch::Connection, '#run' do
+  subject { object.run(request) }
+
+  let(:object) { described_class.new(connection, logger) }
+
+  let(:connection) { mock('Connection')                                  }
+  let(:logger)     { DummyLogger.new                                     }
+  let(:request)    { mock('Request', :log_string => 'the-logged-string') }
+  let(:response)   { mock('Response', :status => 200)                    }
+
+  class DummyLogger
+    attr_reader :messages
+
+    def initialize
+      @messages = []
+    end
+    
+    def debug 
+      @messages << yield
+    end
+  end
+
+  before do
+    request.should_receive(:run).with(connection).and_return(response)
+  end
+
+  it { should be(response) }
+
+  it 'should log requests' do
+    subject
+    logger.messages.should eql(%w(the-logged-string 200))
+  end
+
+end

data/spec/unit/esearch/document/connection_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Esearch::Document, '#connection' do
+  subject { object.connection }
+
+  let(:object)             { described_class.new(type, id)           }
+  let(:type)               { mock('Type', :connection => connection) }
+  let(:connection)         { mock('Connection')                      }
+  let(:id)                 { '1'                                     }
+
+  it { should be(connection) }
+end

data/spec/unit/esearch/document/delete_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Esearch::Document, '#delete' do
+  subject { object.delete}
+
+  let(:object)             { described_class.new(type, id) }
+  let(:type)               { mock('Type')                  }
+  let(:id)                 { '1'                           }
+  let(:expected_arguments) { []                            }
+
+  expect_to_run_command(Esearch::Command::Document::Delete)
+end

data/spec/unit/esearch/document/get_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Esearch::Document, '#get' do
+  subject { object.get}
+
+  let(:object)             { described_class.new(type, id) }
+  let(:type)               { mock('Type')                  }
+  let(:id)                 { '1'                           }
+  let(:expected_arguments) { []                            }
+
+  expect_to_run_command(Esearch::Command::Document::Get)
+end

data/spec/unit/esearch/index/create_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Esearch::Index, '#create' do
+  subject { object.create(settings) }
+
+  let(:object)             { described_class.new(connection, index_name) }
+  let(:index_name)         { 'foo'                }
+  let(:settings)           { { :my => :settings } }
+  let(:expected_arguments) { [settings]           }
+
+  expect_to_run_command(Esearch::Command::Index::Create)
+end

data/spec/unit/esearch/index/delete_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Esearch::Index, '#delete' do
+  subject { object.delete }
+
+  let(:object)             { described_class.new(connection, index_name) }
+  let(:index_name)         { 'foo' }
+  let(:expected_arguments) { [] }
+
+  expect_to_run_command(Esearch::Command::Index::Delete)
+end

data/spec/unit/esearch/index/type_spec.rb

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

data/spec/unit/esearch/indices/all/path_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Esearch::Indices::All, '#path' do
+  subject { object.path }
+
+  let(:object) { described_class.new(connection) }
+  let(:connection) { mock('Connection') }
+
+  it { should eql(Pathname.new('/_all')) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/esearch/mixin/document/index_create_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Esearch::Mixin::Document, '#index_create' do
+
+  let(:object) { class_under_test.new(connection) }
+
+  let(:class_under_test) do
+    Class.new do
+      include Concord.new(:connection), Esearch::Mixin::Document
+    end
+  end
+
+  context 'with one arg' do
+    subject { object.index_create(document) }
+    let(:document) { mock('Document') }
+
+    let(:expected_arguments) { [document, {}] }
+
+    expect_to_run_command(Esearch::Command::Document::Index::Create)
+  end
+
+  context 'with two args' do
+    subject { object.index_create(document, options) }
+    let(:document) { mock('Document') }
+    let(:options)  { mock('Options') }
+
+    let(:expected_arguments) { [document, options] }
+
+    expect_to_run_command(Esearch::Command::Document::Index::Create)
+  end
+end