elastomer-client 0.3.1

data/test/client/index_test.rb

@@ -0,0 +1,244 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe Elastomer::Client::Index do
+
+  before do
+    @name  = 'elastomer-index-test'
+    @index = $client.index @name
+    @index.delete if @index.exists?
+  end
+
+  after do
+    @index.delete if @index.exists?
+  end
+
+  it 'requires an index name' do
+    assert_raises(ArgumentError) { $client.index }
+  end
+
+  it 'determines if an index exists' do
+    assert !@index.exists?, 'the index should not yet exist'
+  end
+
+  describe 'when creating an index' do
+    it 'creates an index' do
+      @index.create :settings => { :number_of_shards => 3, :number_of_replicas => 0 }
+      assert @index.exists?, 'the index should now exist'
+
+      settings = @index.settings[@name]['settings']
+
+      # COMPATIBILITY
+      # ES 1.0 changed the default return format of index settings to always
+      # expand nested properties, e.g.
+      # {"index.number_of_replicas": "1"} changed to
+      # {"index": {"number_of_replicas":"1"}}
+
+      # To support both versions, we check for either return format.
+      value = settings['index.number_of_shards'] ||
+              settings['index']['number_of_shards']
+      assert_equal '3', value
+      value = settings['index.number_of_replicas'] ||
+              settings['index']['number_of_replicas']
+      assert_equal '0', value
+    end
+
+    it 'adds mappings for document types' do
+      @index.create(
+        :settings => { :number_of_shards => 1, :number_of_replicas => 0 },
+        :mappings => {
+          :doco => {
+            :_source => { :enabled => false },
+            :_all    => { :enabled => false },
+            :properties => {
+              :title  => { :type => 'string', :analyzer => 'standard' },
+              :author => { :type => 'string', :index => 'not_analyzed' }
+            }
+          }
+        }
+      )
+
+      assert @index.exists?, 'the index should now exist'
+      assert_mapping_exists @index.mapping[@name], 'doco'
+    end
+  end
+
+  it 'updates index settings' do
+    @index.create :settings => { :number_of_shards => 1, :number_of_replicas => 0 }
+
+    @index.update_settings 'index.number_of_replicas' => 1
+    settings = @index.settings[@name]['settings']
+
+    # COMPATIBILITY
+    # ES 1.0 changed the default return format of index settings to always
+    # expand nested properties, e.g.
+    # {"index.number_of_replicas": "1"} changed to
+    # {"index": {"number_of_replicas":"1"}}
+
+    # To support both versions, we check for either return format.
+    value = settings['index.number_of_replicas'] ||
+            settings['index']['number_of_replicas']
+    assert_equal '1', value
+  end
+
+  it 'updates document mappings' do
+    @index.create(
+      :mappings => {
+        :doco => {
+          :_source => { :enabled => false },
+          :_all    => { :enabled => false },
+          :properties => {:title  => { :type => 'string', :analyzer => 'standard' }}
+        }
+      }
+    )
+
+    assert_property_exists @index.mapping[@name], 'doco', 'title'
+
+    @index.update_mapping 'doco', { :doco => { :properties => {
+      :author => { :type => 'string', :index => 'not_analyzed' }
+    }}}
+
+    assert_property_exists @index.mapping[@name], 'doco', 'author'
+    assert_property_exists @index.mapping[@name], 'doco', 'title'
+
+    @index.update_mapping 'mux_mool', { :mux_mool => { :properties => {
+      :song => { :type => 'string', :index => 'not_analyzed' }
+    }}}
+
+    assert_property_exists @index.mapping[@name], 'mux_mool', 'song'
+  end
+
+  it 'deletes document mappings' do
+    @index.create(
+      :mappings => {
+        :doco => {
+          :_source => { :enabled => false },
+          :_all    => { :enabled => false },
+          :properties => {:title  => { :type => 'string', :analyzer => 'standard' }}
+        }
+      }
+    )
+    assert_mapping_exists @index.mapping[@name], 'doco'
+
+    response = @index.delete_mapping 'doco'
+    assert_acknowledged response
+    assert @index.mapping == {} || @index.mapping[@name] == {}
+  end
+
+  it 'lists all aliases to the index' do
+    @index.create(nil)
+    assert_equal({@name => {'aliases' => {}}}, @index.get_aliases)
+
+    $client.cluster.update_aliases :add => {:index => @name, :alias => 'foofaloo'}
+    assert_equal({@name => {'aliases' => {'foofaloo' => {}}}}, @index.get_aliases)
+  end
+
+  # COMPATIBILITY ES 1.x removed English stopwords from the default analyzers,
+  # so create a custom one with the English stopwords added.
+  if es_version_1_x?
+    it 'analyzes text and returns tokens' do
+      tokens = @index.analyze 'Just a few words to analyze.', :analyzer => 'standard', :index => nil
+      tokens = tokens['tokens'].map { |h| h['token'] }
+      assert_equal %w[just a few words to analyze], tokens
+
+      @index.create(
+        :settings => {
+          :number_of_shards => 1,
+          :number_of_replicas => 0,
+          :analysis => {
+            :analyzer => {
+              :english_standard => {
+                :type => :standard,
+                :stopwords => "_english_"
+              }
+            }
+          }
+        }
+      )
+
+      tokens = @index.analyze 'Just a few words to analyze.', :analyzer => 'english_standard'
+      tokens = tokens['tokens'].map { |h| h['token'] }
+      assert_equal %w[just few words analyze], tokens
+    end
+  else
+    it 'analyzes text and returns tokens' do
+      tokens = @index.analyze 'Just a few words to analyze.', :index => nil
+      tokens = tokens['tokens'].map { |h| h['token'] }
+      assert_equal %w[just few words analyze], tokens
+
+      tokens = @index.analyze 'Just a few words to analyze.', :analyzer => 'simple', :index => nil
+      tokens = tokens['tokens'].map { |h| h['token'] }
+      assert_equal %w[just a few words to analyze], tokens
+    end
+  end
+
+  describe "when an index exists" do
+    before do
+      @index.create(nil)
+      wait_for_index(@name)
+    end
+
+    #TODO assert this only hits the desired index
+    it 'deletes' do
+      response = @index.delete
+      assert_acknowledged response
+    end
+
+    it 'opens' do
+      response = @index.open
+      assert_acknowledged response
+    end
+
+    it 'closes' do
+      response = @index.close
+      assert_acknowledged response
+    end
+
+    it 'refreshes' do
+      response = @index.refresh
+      assert_equal 0, response["_shards"]["failed"]
+    end
+
+    it 'flushes' do
+      response = @index.flush
+      assert_equal 0, response["_shards"]["failed"]
+    end
+
+    it 'optimizes' do
+      response = @index.optimize
+      assert_equal 0, response["_shards"]["failed"]
+    end
+
+    # COMPATIBILITY ES 1.2 removed support for the gateway snapshot API.
+    if es_version_supports_gateway_snapshots?
+      it 'snapshots' do
+        response = @index.snapshot
+        assert_equal 0, response["_shards"]["failed"]
+      end
+    end
+
+    it 'clears caches' do
+      response = @index.clear_cache
+      assert_equal 0, response["_shards"]["failed"]
+    end
+
+    it 'gets stats' do
+      response = @index.stats
+      if response.key? 'indices'
+        assert_includes response["indices"], "elastomer-index-test"
+      else
+        assert_includes response["_all"]["indices"], "elastomer-index-test"
+      end
+    end
+
+    it 'gets status' do
+      response = @index.status
+      assert_includes response["indices"], "elastomer-index-test"
+    end
+
+    it 'gets segments' do
+      @index.docs('foo').index("foo" => "bar")
+      response = @index.segments
+      assert_includes response["indices"], "elastomer-index-test"
+    end
+  end
+end

data/test/client/multi_search_test.rb

@@ -0,0 +1,129 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe Elastomer::Client::MultiSearch do
+
+  before do
+    @name  = 'elastomer-msearch-test'
+    @index = $client.index(@name)
+
+    unless @index.exists?
+      @index.create \
+        :settings => { 'index.number_of_shards' => 1, 'index.number_of_replicas' => 0 },
+        :mappings => {
+          :doc1 => {
+            :_source => { :enabled => true }, :_all => { :enabled => false },
+            :properties => {
+              :title  => { :type => 'string', :analyzer => 'standard' },
+              :author => { :type => 'string', :index => 'not_analyzed' }
+            }
+          },
+          :doc2 => {
+            :_source => { :enabled => true }, :_all => { :enabled => false },
+            :properties => {
+              :title  => { :type => 'string', :analyzer => 'standard' },
+              :author => { :type => 'string', :index => 'not_analyzed' }
+            }
+          }
+        }
+
+      wait_for_index(@name)
+    end
+
+    @docs = @index.docs
+  end
+
+  after do
+    @index.delete if @index.exists?
+  end
+
+  it 'performs multisearches' do
+    populate!
+
+    body = [
+      '{"index" : "elastomer-msearch-test", "search_type" : "count"}',
+      '{"query" : {"match_all" : {}}}',
+      '{"index" : "elastomer-msearch-test", "type": "doc2"}',
+      '{"query" : {"match": {"author" : "grantr"}}}',
+      nil
+    ]
+    body = body.join "\n"
+    h = $client.multi_search body
+    response1, response2 = h["responses"]
+    assert_equal 4, response1["hits"]["total"]
+    assert_equal 1, response2["hits"]["total"]
+    assert_equal "2", response2["hits"]["hits"][0]["_id"]
+
+    body = [
+      '{}',
+      '{"query" : {"match": {"author" : "grantr"}}}',
+      nil
+    ]
+    body = body.join "\n"
+    h = $client.multi_search body, :index => @name
+    response1 = h["responses"].first
+    assert_equal 1, response1["hits"]["total"]
+    assert_equal "2", response1["hits"]["hits"][0]["_id"]
+  end
+
+  it 'supports a nice block syntax' do
+    populate!
+
+    h = $client.multi_search do |m|
+      m.search({:query => { :match_all => {}}}, :index => @name, :search_type => :count)
+      m.search({:query => { :match => { "title" => "author" }}}, :index => @name, :type => 'doc2')
+    end
+
+    response1, response2 = h["responses"]
+
+    assert_equal 4, response1["hits"]["total"]
+    assert_equal 2, response2["hits"]["total"]
+
+    h = @index.multi_search do |m|
+      m.search({:query => { :match_all => {}}}, :search_type => :count)
+      m.search({:query => { :match => { "title" => "author" }}}, :type => 'doc2')
+    end
+
+    response1, response2 = h["responses"]
+
+    assert_equal 4, response1["hits"]["total"]
+    assert_equal 2, response2["hits"]["total"]
+
+    h = @index.docs('doc1').multi_search do |m|
+      m.search({:query => { :match_all => {}}}, :search_type => :count)
+      m.search({:query => { :match => { "title" => "logging" }}}, :type => 'doc2')
+    end
+
+    response1, response2 = h["responses"]
+
+    assert_equal 2, response1["hits"]["total"]
+    assert_equal 1, response2["hits"]["total"]
+  end
+
+  def populate!
+    @docs.add \
+      :_id    => 1,
+      :_type  => 'doc1',
+      :title  => 'the author of gravatar',
+      :author => 'mojombo'
+
+    @docs.add \
+      :_id    => 2,
+      :_type  => 'doc1',
+      :title  => 'the author of resque',
+      :author => 'defunkt'
+
+    @docs.add \
+      :_id    => 1,
+      :_type  => 'doc2',
+      :title  => 'the author of logging',
+      :author => 'pea53'
+
+    @docs.add \
+      :_id    => 2,
+      :_type  => 'doc2',
+      :title  => 'the author of rubber-band',
+      :author => 'grantr'
+
+    @index.refresh
+  end
+end

data/test/client/nodes_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe Elastomer::Client::Nodes do
+
+  it 'gets info for the ndoe(s)' do
+    h = $client.nodes.info
+    assert h.key?('cluster_name'), 'the cluster name is returned'
+    assert_instance_of Hash, h['nodes'], 'the node list is returned'
+  end
+
+  it 'gets stats for the node(s)' do
+    h = $client.nodes.stats
+    assert_instance_of Hash, h['nodes'], 'the node list is returned'
+
+    node = h['nodes'].values.first
+    assert node.key?('indices'), 'indices stats are returned'
+  end
+
+  it 'gets the hot threads for the node(s)' do
+    str = $client.nodes.hot_threads :read_timeout => 2
+    assert_instance_of String, str
+    assert_match %r/cpu usage by thread/, str
+  end
+
+  it 'can be scoped to a single node' do
+    h = $client.nodes('node-with-no-name').info
+    assert_empty h['nodes']
+  end
+
+  it 'can be scoped to a multiple nodes' do
+    h = $client.nodes(%w[node1 node2 node3]).info
+    assert_empty h['nodes']
+  end
+
+end

data/test/client/scan_test.rb

@@ -0,0 +1,84 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe Elastomer::Client::Scan do
+
+  before do
+    @name  = 'elastomer-scan-test'
+    @index = $client.index(@name)
+
+    unless @index.exists?
+      @index.create \
+        :settings => { 'index.number_of_shards' => 1, 'index.number_of_replicas' => 0 },
+        :mappings => {
+          :tweet => {
+            :_source => { :enabled => true }, :_all => { :enabled => false },
+            :properties => {
+              :message => { :type => 'string', :analyzer => 'standard' },
+              :author  => { :type => 'string', :index => 'not_analyzed' }
+            }
+          },
+          :book => {
+            :_source => { :enabled => true }, :_all => { :enabled => false },
+            :properties => {
+              :title  => { :type => 'string', :analyzer => 'standard' },
+              :author => { :type => 'string', :index => 'not_analyzed' }
+            }
+          }
+        }
+
+      wait_for_index(@name)
+      populate!
+    end
+  end
+
+  it 'scans over all documents in an index' do
+    scan = @index.scan '{"query":{"match_all":{}}}', :size => 10
+
+    counts = {'tweet' => 0, 'book' => 0}
+    scan.each_document { |h| counts[h['_type']] += 1 }
+
+    assert_equal 50, counts['tweet']
+    assert_equal 25, counts['book']
+  end
+
+  it 'restricts the scan to a single document type' do
+    scan = @index.scan '{"query":{"match_all":{}}}', :type => 'book'
+
+    counts = {'tweet' => 0, 'book' => 0}
+    scan.each_document { |h| counts[h['_type']] += 1 }
+
+    assert_equal 0, counts['tweet']
+    assert_equal 25, counts['book']
+  end
+
+  it 'limits results by query' do
+    scan = @index.scan :query => { :bool => { :should => [
+      {:match => {:author => 'pea53'}},
+      {:match => {:title => '17'}}
+    ]}}
+
+    counts = {'tweet' => 0, 'book' => 0}
+    scan.each_document { |h| counts[h['_type']] += 1 }
+
+    assert_equal 50, counts['tweet']
+    assert_equal 1, counts['book']
+  end
+
+  def populate!
+    h = @index.bulk do |b|
+      50.times { |num|
+        b.index %Q({"author":"pea53","message":"this is tweet number #{num}"}), :_id => num, :_type => 'tweet'
+      }
+    end
+    h['items'].each {|item| assert_bulk_index(item) }
+
+    h = @index.bulk do |b|
+      25.times { |num|
+        b.index %Q({"author":"Pratchett","title":"DiscWorld Book #{num}"}), :_id => num, :_type => 'book'
+      }
+    end
+    h['items'].each {|item| assert_bulk_index(item) }
+
+    @index.refresh
+  end
+end