esearch 0.2.0

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Esearch::Mixin::Document, '#index' 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(document) }
+    let(:document) { mock('Document') }
+
+    let(:expected_arguments) { [document, {}] }
+
+    expect_to_run_command(Esearch::Command::Document::Index)
+  end
+
+  context 'with two args' do
+    subject { object.index(document, options) }
+    let(:document) { mock('Document') }
+    let(:options)  { mock('Options') }
+
+    let(:expected_arguments) { [document, options] }
+
+    expect_to_run_command(Esearch::Command::Document::Index)
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Esearch::Mixin::Document, '#index_update' 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_update(document) }
+    let(:document) { mock('Document') }
+
+    let(:expected_arguments) { [document, {}] }
+
+    expect_to_run_command(Esearch::Command::Document::Index::Update)
+  end
+
+  context 'with two args' do
+    subject { object.index_update(document, options) }
+    let(:document) { mock('Document') }
+    let(:options)  { mock('Options') }
+
+    let(:expected_arguments) { [document, options] }
+
+    expect_to_run_command(Esearch::Command::Document::Index::Update)
+  end
+end

data/spec/unit/esearch/mixin/exist/exist_predicate_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Esearch::Mixin::Exist, '#exist?' do
+  subject { object.exist? }
+
+  let(:object) { class_under_test.new(connection) }
+
+  let(:class_under_test) do
+    Class.new do
+      include Concord.new(:connection), Esearch::Mixin::Exist
+    end
+  end
+
+  let(:expected_arguments) { [] }
+  expect_to_run_command(Esearch::Command::Exist)
+end

data/spec/unit/esearch/mixin/index/refresh_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Esearch::Mixin::Index, '#refresh' do
+  subject { object.refresh }
+
+  let(:object) { class_under_test.new(connection) }
+
+  let(:class_under_test) do
+    Class.new do
+      include Concord.new(:connection), Esearch::Mixin::Index
+    end
+  end
+
+  let(:expected_arguments) { [] }
+  expect_to_run_command(Esearch::Command::Index::Refresh)
+end

data/spec/unit/esearch/mixin/index/status_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Esearch::Mixin::Index, '#status' do
+  subject { object.status }
+
+  let(:object) { class_under_test.new(connection) }
+
+  let(:class_under_test) do
+    Class.new do
+      include Concord.new(:connection), Esearch::Mixin::Index
+    end
+  end
+
+  let(:expected_arguments) { [] }
+  expect_to_run_command(Esearch::Command::Status)
+end

data/spec/unit/esearch/mixin/search/search_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Esearch::Mixin::Search, '#search' do
+  subject { object.search(query) }
+
+  let(:object) { class_under_test.new(connection) }
+
+  let(:class_under_test) do
+    Class.new do
+      include Concord.new(:connection), Esearch::Mixin::Search
+    end
+  end
+
+  let(:query) { mock('Query') }
+  let(:expected_arguments) { [query] }
+
+  expect_to_run_command(Esearch::Command::Search)
+end

data/spec/unit/esearch/presenter/aspect/range/from_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Esearch::Presenter::Aspect::Range, '#from' do
+  subject { object.from }
+
+  let(:object) { described_class.new(raw) }
+  let(:value) { mock('Value') }
+
+  context 'when _source is present' do
+    let(:raw) { { 'from' => value } }
+
+    it { should be(value) }
+
+    it_should_behave_like 'an idempotent method' 
+  end
+
+  context 'when _source is NOT present' do
+    let(:raw) { {} }
+
+    it { should be(nil) }
+
+    it_should_behave_like 'an idempotent method' 
+  end
+end

data/spec/unit/esearch/presenter/aspect/range/to_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Esearch::Presenter::Aspect::Range, '#to' do
+  subject { object.to }
+
+  let(:object) { described_class.new(raw) }
+  let(:value) { mock('Value') }
+
+  context 'when _source is present' do
+    let(:raw) { { 'to' => value } }
+
+    it { should be(value) }
+
+    it_should_behave_like 'an idempotent method' 
+  end
+
+  context 'when _source is NOT present' do
+    let(:raw) { {} }
+
+    it { should be(nil) }
+
+    it_should_behave_like 'an idempotent method' 
+  end
+end

data/spec/unit/esearch/presenter/class_methods/new_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Esearch::Presenter, '.new' do
+  let(:object) { class_under_test }
+
+  subject { object.new(raw) }
+
+  let(:value) { mock('Value') }
+
+  class DummyPresenter
+    include Concord.new(:raw) 
+  end
+
+  context 'with exposed tagged collection' do
+    let(:raw) { { 'foo' => { 'bar' => { 'baz' => 'bor' } } } }
+
+    let(:class_under_test) do
+      Class.new(described_class) do
+        expose_tagged_collection(:foo, DummyPresenter)
+      end
+    end
+
+    its(:foo) { should eql([DummyPresenter.new('baz' => 'bor', 'name' => 'bar')]) }
+  end
+
+  context 'with exposed primitive' do
+    let(:raw) { { 'foo' => value } }
+
+    let(:class_under_test) do
+      Class.new(described_class) do
+        expose_primitive :foo
+      end
+    end
+
+    its(:foo) { should be(value) }
+  end
+end

data/spec/unit/esearch/presenter/facet/build_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Esearch::Presenter::Facet, '.build' do
+  subject { object.build(raw) }
+
+  let(:object) { described_class }
+
+  context 'when type is "terms"' do
+    let(:raw) { { '_type' => 'terms' } }
+    it { should eql(Esearch::Presenter::Facet::Terms.new(raw)) }
+  end
+
+  context 'when type is "range"' do
+    let(:raw) { { '_type' => 'range' } }
+    it { should eql(Esearch::Presenter::Facet::Range.new(raw)) }
+  end
+
+  context 'with unknown type' do
+    let(:raw) { { '_type' => 'foo' } }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error('Facet with type "foo" is not known')
+    end
+  end
+
+end

data/spec/unit/esearch/presenter/facet/class_methods/build_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Esearch::Presenter::Facet, '.build' do
+  subject { object.build(raw) }
+
+  let(:object) { described_class }
+
+  context 'when type is "terms"' do
+    let(:raw) { { '_type' => 'terms' } }
+    it { should eql(Esearch::Presenter::Facet::Terms.new(raw)) }
+  end
+
+  context 'when type is "range"' do
+    let(:raw) { { '_type' => 'range' } }
+    it { should eql(Esearch::Presenter::Facet::Range.new(raw)) }
+  end
+
+  context 'with unknown type' do
+    let(:raw) { { '_type' => 'foo' } }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error('Facet with type "foo" is not known')
+    end
+  end
+
+end

data/spec/unit/esearch/presenter/hit/fields_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Esearch::Presenter::Hit, '#fields' do
+  subject { object.fields }
+
+  let(:object) { described_class.new(raw) }
+  let(:value) { mock('Value') }
+
+  context 'when fields is present' do
+    let(:raw) { { 'fields' => value } }
+
+    it { should be(value) }
+
+    it_should_behave_like 'an idempotent method' 
+  end
+
+  context 'when fields is NOT present' do
+    let(:raw) { {} }
+
+    it { should be(nil) }
+
+    it_should_behave_like 'an idempotent method' 
+  end
+end

data/spec/unit/esearch/presenter/hit/source_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Esearch::Presenter::Hit, '#source' do
+  subject { object.source }
+
+  let(:object) { described_class.new(raw) }
+  let(:value) { mock('Value') }
+
+  context 'when _source is present' do
+    let(:raw) { { '_source' => value } }
+
+    it { should be(value) }
+
+    it_should_behave_like 'an idempotent method' 
+  end
+
+  context 'when _source is NOT present' do
+    let(:raw) { {} }
+
+    it { should be(nil) }
+
+    it_should_behave_like 'an idempotent method' 
+  end
+end

data/spec/unit/esearch/presenter/hits/each_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Esearch::Presenter::Hits, '#each' do
+  subject { object.each { |hit| yields << hit } }
+
+  let(:object) { described_class.new(raw) }
+  let(:yields) { [] }
+  let(:hit_a) { mock('Hit A') }
+  let(:hit_b) { mock('Hit B') }
+  let(:raw)    { { 'hits' => [ hit_a, hit_b ] } }
+
+  it_should_behave_like 'an #each method'
+
+  its(:to_a) { should eql([Esearch::Presenter::Hit.new(hit_a), Esearch::Presenter::Hit.new(hit_b)]) }
+end

data/spec/unit/esearch/presenter/hits/size_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Esearch::Presenter::Hits, '#size' do
+  subject { object.size }
+
+  let(:object) { described_class.new(raw) }
+  let(:size)   { mock('Size') }
+  let(:raw)    { { 'hits' => mock(:size => size)} }
+
+  it { should be(size) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/esearch/request/initialize_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Esearch::Request, '.new' do
+  let(:object) { described_class }
+
+  subject { object.new(*arguments) }
+
+  let(:verb)   { mock('Verb')   }
+  let(:path)   { '/some/path'   }
+  let(:params) { mock('Params') }
+  let(:body)   { mock('Body')   }
+
+  context 'with two args' do
+    let(:arguments) { [ verb, path ] }
+
+    its(:verb)   { should be(verb) }
+    its(:path)   { should be(path) }
+    its(:body)   { should be(described_class::EMPTY_HASH) }
+    its(:params) { should be(described_class::EMPTY_HASH) }
+  end
+
+  context 'with three args' do
+    let(:arguments) { [ verb, path, body ] }
+
+    its(:verb)   { should be(verb) }
+    its(:path)   { should be(path) }
+    its(:body)   { should be(body) }
+    its(:params) { should be(described_class::EMPTY_HASH) }
+  end
+
+  context 'with four args' do
+    let(:arguments) { [ verb, path, body, params ] }
+
+    its(:verb)   { should be(verb)   }
+    its(:path)   { should be(path)   }
+    its(:body)   { should be(body)   }
+    its(:params) { should be(params) }
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Esearch::Request, '#run' do
+  let(:object) { described_class.new(verb, path, body, params) }
+
+  subject { object.run(connection) }
+
+  let(:verb)   { :get }
+  let(:path)   { '/some/random/path' }
+  let(:body)   { { 'foo' => 'bar' } }
+  let(:params) { { 'baz' => 'buz' } }
+
+  let(:response_status)  { mock('Status') }
+  let(:response_headers) { {}             }
+  let(:response_body)    { mock('Body')   }
+
+  let(:connection) do
+    Faraday.new do |builder|
+      builder.adapter :test, stubs
+    end
+  end
+
+  let(:stubs) do
+    Faraday::Adapter::Test::Stubs.new do |stub|
+      stub.get('/some/random/path') do |env| 
+        env.fetch(:request_headers).fetch('Content-Type').should eql('application/json; charset=UTF-8')
+        env.fetch(:method).should be(:get)
+        env.fetch(:params).should eql(params)
+        env.fetch(:url).should eql(URI.parse('http:/some/random/path?baz=buz'))
+        env.fetch(:body).should eql('{"foo":"bar"}')
+        [ response_status, response_headers, response_body ]
+      end
+    end
+  end
+
+  its(:status)  { should  be(response_status)                               }
+  its(:headers) { should eql(Faraday::Utils::Headers.new(response_headers)) }
+  its(:body)    { should  be(response_body)                                 }
+end