waistband 0.8.5 → 0.9.0

data/lib/waistband/result.rb

@@ -0,0 +1,21 @@
+module Waistband
+  class Result
+
+    def initialize(result_hash)
+      @result_hash = result_hash
+    end
+
+    def method_missing(method_name, *args, &block)
+      return @result_hash[method_name.to_s] if @result_hash.keys.include?(method_name.to_s)
+      return @result_hash['_source'][method_name.to_s] if @result_hash['_source'] && @result_hash['_source'].keys.include?(method_name.to_s)
+      nil
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      return true if @result_hash.keys.include?(method_name.to_s)
+      return true if @result_hash['_source'] && @result_hash['_source'].keys.include?(method_name.to_s)
+      super
+    end
+
+  end
+end

data/lib/waistband/search_results.rb

@@ -0,0 +1,53 @@
+require 'waistband/result'
+
+module Waistband
+  class SearchResults
+
+    DEFAULT_PAGE_SIZE = 20
+
+    def initialize(search_hash, options = {})
+      @page = options[:page] || 1
+      @page_size = options[:page_size] || DEFAULT_PAGE_SIZE
+      @search_hash = search_hash
+    end
+
+    def hits
+      raise ::Waistband::Errors::NoSearchHits.new("No search hits!") unless @search_hash['hits']
+      @search_hash['hits']['hits']
+    end
+
+    def results
+      raise ::Waistband::Errors::NoSearchHits.new("No search hits!") unless @search_hash['hits']
+
+      hits.map do |hit|
+        ::Waistband::Result.new(hit)
+      end
+    end
+
+    def paginated_hits
+      raise "Kaminari gem not found for pagination" unless defined?(Kaminari)
+      Kaminari.paginate_array(hits, total_count: total_results).page(@page).per(@page_size)
+    end
+
+    def paginated_results
+      raise "Kaminari gem not found for pagination" unless defined?(Kaminari)
+      Kaminari.paginate_array(results, total_count: total_results).page(@page).per(@page_size)
+    end
+
+    def total_results
+      raise ::Waistband::Errors::NoSearchHits.new("No search hits!") unless @search_hash['hits']
+      @search_hash['hits']['total']
+    end
+
+    def method_missing(method_name, *args, &block)
+      return @search_hash[method_name.to_s] if @search_hash.keys.include?(method_name.to_s)
+      super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      return true if @search_hash.keys.include?(method_name.to_s)
+      super
+    end
+
+  end
+end

data/lib/waistband/version.rb

@@ -1,3 +1,3 @@
 module Waistband
-  VERSION = "0.8.5"
+  VERSION = "0.9.0"
 end

data/spec/config/waistband/waistband.yml

@@ -1,12 +1,16 @@
 development: &DEV
   timeout: 2
+  retries: 5
+  reload_on_failure: true
   servers:
     server1:
-      host: http://localhost
+      host: localhost
       port: 9200
+      protocol: http
     server2:
-      host: http://127.0.0.1
+      host: 127.0.0.1
       port: 9200
+      protocol: http
 
 test:
   <<: *DEV

data/spec/lib/configuration_spec.rb

@@ -5,40 +5,37 @@ describe Waistband::Configuration do
   let(:config) { Waistband.config }
 
   it "loads config yml" do
-    config.host.should match /http\:\/\//
-    config.port.should eql 9200
-    config.timeout.should eql 2
+    expect(config.timeout).to eql 2
   end
 
   it "loads indexes config" do
-    config.index('search').should be_a Hash
-    config.index('search')['settings']['index']['number_of_shards'].should eql 1
+    expect(config.index('search')).to be_a Hash
+    expect(config.index('search')['settings']['index']['number_of_shards']).to eql 1
   end
 
   it "loads multiple indexes config" do
-    config.index('events').should be_a Hash
-    config.index('events')['settings']['index']['number_of_shards'].should eql 1
+    expect(config.index('events')).to be_a Hash
+    expect(config.index('events')['settings']['index']['number_of_shards']).to eql 1
   end
 
-  describe '#servers' do
+  it "proxies the client" do
+    expect(::Waistband.config.client).to be_a ::Elasticsearch::Transport::Client
+    expect(::Waistband.client).to be_a ::Elasticsearch::Transport::Client
+  end
 
-    it "returns array of all available servers' configs" do
-      config.servers.should be_an Array
-      config.servers.size.should eql 2
+  describe '#hosts' do
 
-      config.servers.each_with_index do |server, i|
-        server['host'].should match /http\:\/\//
-        server['port'].should eql 9200
+    it "returns array of all available servers' configs" do
+      expect(config.hosts).to be_an Array
+      expect(config.hosts.size).to eql 2
 
-        server['_id'].should be_present
-        server['_id'].length.should eql 40
+      config.hosts.each_with_index do |server, i|
+        expect(server['host']).to match /127\.0\.0\.1|localhost/
+        expect(server['port']).to eql 9200
+        expect(server['protocol']).to eql 'http'
       end
     end
 
-    it "servers ids should be unique" do
-      config.servers[0]['_id'].should_not eql config.servers[1]['_id']
-    end
-
   end
 
 end

data/spec/lib/index_spec.rb

@@ -7,66 +7,93 @@ describe Waistband::Index do
   let(:attrs)   { {'ok' => {'yeah' => true}} }
 
   it "initializes values" do
-    index.instance_variable_get('@stringify').should  eql true
+    expect(index.instance_variable_get('@stringify')).to eql true
   end
 
   it "creates the index" do
-    index.destroy!
-    expect{ index.refresh! }.to raise_error(Waistband::Connection::Error::Resquest)
+    index.delete!
+    expect{ index.refresh }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
 
     index.create!
-    expect{ index.refresh! }.to_not raise_error
+    expect{ index.refresh }.to_not raise_error
   end
 
-  it "destroys the index" do
-    index.destroy!
-    expect{ index.refresh! }.to raise_error(Waistband::Connection::Error::Resquest)
+  it "deletes the index" do
+    index.delete!
+    expect{ index.refresh }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
     index.create!
   end
 
+  it "blows up when trying to delete an index that does not exist" do
+    index.delete!
+    expect { index.delete! }.to raise_error(::Waistband::Errors::IndexNotFound)
+  end
+
+  it "updates the index's mappings" do
+    index.refresh
+    response = index.update_mapping('event')
+    expect(response['acknowledged']).to be_true
+  end
+
   it "updates the index's settings" do
     index.refresh
-    response = JSON.parse(index.update_settings!)
-    response['ok'].should be_true
+    response = index.update_settings
+    expect(response['acknowledged']).to be_true
   end
 
-  it "proxies to a query" do
-    index.query.should be_a Waistband::Query
+  it "proxies to the client's search" do
+    result = index.search({})
+    expect(result).to be_a Waistband::SearchResults
+    expect(result.took).to be_present
+    expect(result.hits).to be_an Array
   end
 
   describe "storing" do
 
     it "stores data" do
-      index.store!('__test_write', {'ok' => 'yeah'})
-      index.read('__test_write').should eql({'ok' => 'yeah'})
+      expect(index.save('__test_write', {'ok' => 'yeah'})).to be_true
+      expect(index.read('__test_write')).to eql({
+        '_id' => '__test_write',
+        '_index' => 'events_test',
+        '_source' => {'ok' => 'yeah'},
+        '_type' => 'event',
+        '_version' => 1,
+        'found' => true
+      })
     end
 
     it "data is stringified" do
-      index.store!('__test_write', attrs)
-      index.read('__test_write').should eql({"ok"=>"{\"yeah\"=>true}"})
+      index.save('__test_write', attrs)
+      expect(index.read('__test_write')[:_source]).to eql({"ok"=>"{\"yeah\"=>true}"})
     end
 
     it "data is indirectly accessible when not stringified" do
-      index2.store!('__test_not_string', attrs)
-      index2.read('__test_not_string')[:ok][:yeah].should eql true
+      index2.save('__test_not_string', attrs)
+      expect(index2.read('__test_not_string')[:_source][:ok][:yeah]).to eql true
     end
 
     it "deletes data" do
-      index.store!('__test_write', attrs)
-      index.delete!('__test_write')
-      index.read('__test_write').should be_nil
+      index.save('__test_write', attrs)
+      index.destroy('__test_write')
+      expect(index.read('__test_write')).to be_nil
     end
 
     it "returns nil on 404" do
-      index.read('__not_here').should be_nil
+      expect(index.read('__not_here')).to be_nil
+    end
+
+    it "blows up on 404 when using the bang method" do
+      expect {
+        index.read!('__not_here')
+      }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
     end
 
     it "doesn't mix data between two indexes" do
-      index.store!('__test_write',  {'data' => 'index_1'})
-      index2.store!('__test_write', {'data' => 'index_2'})
+      index.save('__test_write',  {'data' => 'index_1'})
+      index2.save('__test_write', {'data' => 'index_2'})
 
-      index.read('__test_write').should   eql({'data' => 'index_1'})
-      index2.read('__test_write').should  eql({'data' => 'index_2'})
+      expect(index.read('__test_write')[:_source]).to   eql({'data' => 'index_1'})
+      expect(index2.read('__test_write')[:_source]).to  eql({'data' => 'index_2'})
     end
 
   end
@@ -76,26 +103,24 @@ describe Waistband::Index do
     let(:sharded_index) { Waistband::Index.new('events', subs: %w(2013 01)) }
 
     it "permits subbing the index" do
-      sharded_index.name.should eql 'events__2013_01'
-      sharded_index.config_name.should eql 'events_test__2013_01'
+      expect(sharded_index.send(:config_name)).to eql 'events_test__2013_01'
     end
 
     it "permits sharding into singles" do
       index = Waistband::Index.new 'events', subs: '2013'
-      index.name.should eql 'events__2013'
-      index.config_name.should eql 'events_test__2013'
+      expect(index.send(:config_name)).to eql 'events_test__2013'
     end
 
     it "retains the same options from the parent index config" do
       config = sharded_index.send(:config)
 
-      sharded_index.base_config_name.should eql 'events_test'
-      config['stringify'].should be_true
-      config['settings'].should be_present
+      expect(sharded_index.send(:base_config_name)).to eql 'events_test'
+      expect(config['stringify']).to be_true
+      expect(config['settings']).to be_present
     end
 
     it "creates the sharded index with the same mappings as the parent" do
-      sharded_index.destroy
+      sharded_index.delete!
 
       expect {
         sharded_index.create!
@@ -106,7 +131,7 @@ describe Waistband::Index do
 
       it "gets a default name that makes sense for the index when not defined" do
         index = Waistband::Index.new 'events_no_name', subs: %w(2013 01)
-        index.config_name.should eql 'events_no_name_test__2013_01'
+        expect(index.send(:config_name)).to eql 'events_no_name_test__2013_01'
       end
 
     end
@@ -117,7 +142,22 @@ describe Waistband::Index do
 
     it "gets a default name that makes sense for the index when not defined" do
       index = Waistband::Index.new 'events_no_name'
-      index.base_config_name.should eql 'events_no_name_test'
+      expect(index.send(:base_config_name)).to eql 'events_no_name_test'
+    end
+
+  end
+
+  describe 'aliases' do
+
+    it "returns the alias name with the env" do
+      expect(index.send(:full_alias_name, 'all_events')).to eql 'all_events_test'
+    end
+
+    it "if the index has a custom name, the alias name doesn't automatically append the env" do
+      index.stub(:config).and_return({
+        'name' => 'super_custom'
+      })
+      expect(index.send(:full_alias_name, 'all_events')).to eql 'all_events'
     end
 
   end

data/spec/lib/result_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe ::Waistband::Result do
+
+  let(:result_hash) do
+    {
+      "_index" => "bus_events",
+      "_type" => "bus_event",
+      "_id" => "a2081c0ce39b25d50b0a4be3c116ee7f",
+      "_score" => nil,
+      "_source" => {
+        "bus_event_type" => "task_opened",
+        "timeline_event" => "true",
+        "_message" => "true"
+      },
+      "sort" => [nil]
+    }
+  end
+
+  let(:result) { ::Waistband::Result.new(result_hash) }
+
+  it "provides accessors for all default fields" do
+    expect(result._id).to eql 'a2081c0ce39b25d50b0a4be3c116ee7f'
+    expect(result._score).to be_nil
+    expect(result._type).to eql 'bus_event'
+    expect(result._index).to eql 'bus_events'
+    expect(result.sort).to eql([nil])
+    expect(result._source).to eql({
+      "bus_event_type" => "task_opened",
+      "timeline_event" => "true",
+      "_message" => "true"
+    })
+  end
+
+  it "provides method missing interface for the _source hash" do
+    expect(result.bus_event_type).to eql 'task_opened'
+    expect(result.timeline_event).to be_true
+    expect(result._message).to be_true
+  end
+
+end

data/spec/lib/search_results_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe ::Waistband::SearchResults do
+
+  let(:search_hash) do
+    {
+      "took" => 1,
+      "timed_out" => false,
+      "_shards" => {
+        "total" => 12,
+        "successful" => 12,
+        "failed" => 0
+      },
+      "hits" => {
+        "total" => 1,
+        "max_score" => nil,
+        "hits" => [{
+          "_index" => "bus_events",
+          "_type" => "bus_event",
+          "_id" => "a2081c0ce39b25d50b0a4be3c116ee7f",
+          "_score" => nil,
+          "_source" => {
+            "bus_event_type" => "task_opened",
+            "timeline_event" => "true",
+            "_message" => "true"
+          },
+          "sort" => [nil]
+        }]
+      }
+    }
+  end
+
+  let(:results) { ::Waistband::SearchResults.new(search_hash) }
+
+  it "provides a method interface for the results hash array" do
+    expect(results.took).to eql 1
+    expect(results.timed_out).to be_false
+    expect(results._shards).to eql({
+      "total" => 12,
+      "successful" => 12,
+      "failed" => 0
+    })
+  end
+
+  it "provides a shortcut to get the total number of hits" do
+    expect(results.total_results).to eql 1
+  end
+
+  it "provides a shortcut to get the hits directly" do
+    expect(results.hits).to be_an Array
+    hit = results.hits.first
+
+    expect(hit['_id']).to eql 'a2081c0ce39b25d50b0a4be3c116ee7f'
+    expect(hit['_source']['bus_event_type']).to eql 'task_opened'
+  end
+
+  it "maps hits to results" do
+    expect(results.results).to be_an Array
+
+    result = results.results.first
+
+    expect(result).to be_a ::Waistband::Result
+    expect(result._id).to eql 'a2081c0ce39b25d50b0a4be3c116ee7f'
+    expect(result._score).to be_nil
+    expect(result._type).to eql 'bus_event'
+    expect(result._index).to eql 'bus_events'
+    expect(result.sort).to eql([nil])
+    expect(result._source).to eql({
+      "bus_event_type" => "task_opened",
+      "timeline_event" => "true",
+      "_message" => "true"
+    })
+    expect(result.bus_event_type).to eql 'task_opened'
+    expect(result.timeline_event).to be_true
+    expect(result._message).to be_true
+  end
+
+  describe '#paginated_hits' do
+
+    it "provides a paginated array from Kaminari if Kaminari is defined" do
+      load 'active_support/concern.rb'
+      load 'kaminari/config.rb'
+      load 'kaminari/models/page_scope_methods.rb'
+      load 'kaminari/models/configuration_methods.rb'
+      load 'kaminari/models/array_extension.rb'
+
+      expect(results.paginated_hits).to be_an ::Kaminari::PaginatableArray
+      expect(results.paginated_hits.total_pages).to eql 1
+      expect(results.paginated_hits.current_page).to eql 1
+    end
+
+    it "blows up when kaminari's not required" do
+      # if we've already required Kaminari from the test above, lets remove
+      Object.send(:remove_const, :Kaminari) if defined?(Kaminari)
+
+      expect { results.paginated_hits }.to raise_error RuntimeError, "Kaminari gem not found for pagination"
+    end
+
+  end
+
+  describe '#paginated_results' do
+
+    it "provides a paginated array from Kaminari if Kaminari is defined" do
+      load 'active_support/concern.rb'
+      load 'kaminari/config.rb'
+      load 'kaminari/models/page_scope_methods.rb'
+      load 'kaminari/models/configuration_methods.rb'
+      load 'kaminari/models/array_extension.rb'
+
+      expect(results.paginated_results).to be_an ::Kaminari::PaginatableArray
+      expect(results.paginated_results.total_pages).to eql 1
+      expect(results.paginated_results.current_page).to eql 1
+    end
+
+    it "blows up when kaminari's not required" do
+      # if we've already required Kaminari from the test above, lets remove
+      Object.send(:remove_const, :Kaminari) if defined?(Kaminari)
+
+      expect { results.paginated_results }.to raise_error RuntimeError, "Kaminari gem not found for pagination"
+    end
+
+  end
+
+end