elastomer-client 0.4.1 → 0.5.0

data/test/client/errors_test.rb

@@ -27,22 +27,26 @@ describe Elastomer::Client::Error do
   end
 
   it "is fatal by default" do
-    assert Elastomer::Client::Error.fatal?, "client errors are fatal by default"
+    assert Elastomer::Client::Error.fatal, "client errors are fatal by default"
 
     error = Elastomer::Client::Error.new "oops!"
     assert !error.retry?, "client errors are not retryable by default"
   end
 
+  it "supports .fatal? alias" do
+    assert Elastomer::Client::Error.fatal?, "client errors support .fatal?"
+  end
+
   it "has some fatal subclasses" do
-    assert Elastomer::Client::ResourceNotFound.fatal?, "Resource not found is fatal"
-    assert Elastomer::Client::ParsingError.fatal?, "Parsing error is fatal"
-    assert Elastomer::Client::SSLError.fatal?, "SSL error is fatal"
-    assert Elastomer::Client::RequestError.fatal?, "Request error is fatal"
+    assert Elastomer::Client::ResourceNotFound.fatal, "Resource not found is fatal"
+    assert Elastomer::Client::ParsingError.fatal, "Parsing error is fatal"
+    assert Elastomer::Client::SSLError.fatal, "SSL error is fatal"
+    assert Elastomer::Client::RequestError.fatal, "Request error is fatal"
   end
 
   it "has some non-fatal subclasses" do
-    assert !Elastomer::Client::TimeoutError.fatal?, "Timeouts are not fatal"
-    assert !Elastomer::Client::ConnectionFailed.fatal?, "Connection failures are not fatal"
-    assert !Elastomer::Client::ServerError.fatal?, "Server errors are not fatal"
+    assert !Elastomer::Client::TimeoutError.fatal, "Timeouts are not fatal"
+    assert !Elastomer::Client::ConnectionFailed.fatal, "Connection failures are not fatal"
+    assert !Elastomer::Client::ServerError.fatal, "Server errors are not fatal"
   end
 end

data/test/client/index_test.rb

@@ -12,19 +12,46 @@ describe Elastomer::Client::Index do
     @index.delete if @index.exists?
   end
 
-  it 'requires an index name' do
-    assert_raises(ArgumentError) { $client.index }
+  it 'does not require an index name' do
+    index = $client.index
+    assert_nil index.name
   end
 
   it 'determines if an index exists' do
     assert !@index.exists?, 'the index should not yet exist'
   end
 
+  it 'determines if an index exists with .exist?' do
+    assert !@index.exist?, '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 }
+      @index.create({})
       assert @index.exists?, 'the index should now exist'
+    end
+
+    it 'creates an index with settings' do
+      @index.create :settings => { :number_of_shards => 3, :number_of_replicas => 0 }
+      settings = @index.get_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 'creates an index with settings with .settings' do
+      @index.create :settings => { :number_of_shards => 3, :number_of_replicas => 0 }
       settings = @index.settings[@name]['settings']
 
       # COMPATIBILITY
@@ -57,6 +84,25 @@ describe Elastomer::Client::Index do
         }
       )
 
+      assert @index.exists?, 'the index should now exist'
+      assert_mapping_exists @index.get_mapping[@name], 'doco'
+    end
+
+    it 'adds mappings for document types with .mapping' 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
@@ -107,6 +153,33 @@ describe Elastomer::Client::Index do
     assert_property_exists @index.mapping[@name], 'mux_mool', 'song'
   end
 
+  it 'updates document mappings with .put_mapping' 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.put_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.put_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 => {
@@ -121,12 +194,22 @@ describe Elastomer::Client::Index do
 
     response = @index.delete_mapping 'doco'
     assert_acknowledged response
-    assert @index.mapping == {} || @index.mapping[@name] == {}
+
+    mapping = @index.get_mapping
+    mapping = mapping[@name] if mapping.key? @name
+    mapping = mapping["mappings"] if mapping.key? "mappings"
+
+    assert_empty mapping, "no mappings are present"
   end
 
   it 'lists all aliases to the index' do
     @index.create(nil)
-    assert_equal({@name => {'aliases' => {}}}, @index.get_aliases)
+
+    if es_version_always_returns_aliases?
+      assert_equal({@name => {'aliases' => {}}}, @index.get_aliases)
+    else
+      assert_equal({@name => {}}, @index.get_aliases)
+    end
 
     $client.cluster.update_aliases :add => {:index => @name, :alias => 'foofaloo'}
     assert_equal({@name => {'aliases' => {'foofaloo' => {}}}}, @index.get_aliases)

data/test/client/multi_search_test.rb

@@ -65,6 +65,35 @@ describe Elastomer::Client::MultiSearch do
     assert_equal "2", response1["hits"]["hits"][0]["_id"]
   end
 
+  it 'performs multisearches with .msearch' 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.msearch 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.msearch 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!
 

data/test/client/repository_test.rb

@@ -7,53 +7,45 @@ describe Elastomer::Client::Repository do
     before do
       @name = 'elastomer-repository-test'
       @repo = $client.repository(@name)
-      @repo.delete if @repo.exists?
-    end
-
-    after do
-      @repo.delete if @repo.exists?
     end
 
     it 'determines if a repo exists' do
       assert_equal false, @repo.exists?
       assert_equal false, @repo.exist?
-      with_tmp_repo do
+      with_tmp_repo(@name) do
         assert_equal true, @repo.exists?
       end
     end
 
     it 'creates repos' do
-      Dir.mktmpdir do |dir|
-        response = @repo.create({:type => 'fs', :settings => {:location => dir}})
-        assert_equal true, response["acknowledged"]
-      end
+      response = create_repo(@name)
+      assert_equal true, response["acknowledged"]
+      delete_repo(@name)
     end
 
     it 'cannot create a repo without a name' do
-      Dir.mktmpdir do |dir|
-        lambda {
-          $client.repository.create({:type => 'fs', :settings => {:location => dir}})
-        }.must_raise ArgumentError
-      end
+      lambda {
+        create_repo(nil)
+      }.must_raise ArgumentError
     end
 
     it 'gets repos' do
-      with_tmp_repo do
-        response = @repo.get
-        refute_nil response[@name]
+      with_tmp_repo do |repo|
+        response = repo.get
+        refute_nil response[repo.name]
       end
     end
 
     it 'gets all repos' do
-      with_tmp_repo do
+      with_tmp_repo do |repo|
         response = $client.repository.get
-        refute_nil response[@name]
+        refute_nil response[repo.name]
       end
     end
 
     it 'gets repo status' do
-      with_tmp_repo do
-        response = @repo.status
+      with_tmp_repo do |repo|
+        response = repo.status
         assert_equal [], response["snapshots"]
       end
     end
@@ -64,28 +56,28 @@ describe Elastomer::Client::Repository do
     end
 
     it 'updates repos' do
-      Dir.mktmpdir do |dir|
-        @repo.create({:type => 'fs', :settings => {:location => dir}})
-        response = @repo.update(:type => 'fs', :settings => {:compress => true, :location => dir})
+      with_tmp_repo do |repo|
+        settings = repo.get[repo.name]['settings']
+        response = repo.update(:type => 'fs', :settings => settings.merge('compress' => true))
         assert_equal true, response["acknowledged"]
-        response = @repo.get
-        assert_equal "true", response[@name]["settings"]["compress"]
+        assert_equal "true", repo.get[repo.name]["settings"]["compress"]
       end
     end
 
     it 'cannot update a repo without a name' do
-      Dir.mktmpdir do |dir|
+      with_tmp_repo do |repo|
         lambda {
-          $client.repository.update({:type => 'fs', :settings => {:location => dir}})
+          settings = repo.get[repo.name]['settings']
+          $client.repository.update(:type => 'fs', :settings => settings.merge('compress' => true))
         }.must_raise ArgumentError
       end
     end
 
     it 'deletes repos' do
-      with_tmp_repo do
-        response = @repo.delete
+      with_tmp_repo do |repo|
+        response = repo.delete
         assert_equal true, response["acknowledged"]
-        assert_equal false, @repo.exists?
+        assert_equal false, repo.exists?
       end
     end
 
@@ -96,12 +88,19 @@ describe Elastomer::Client::Repository do
     end
 
     it 'gets snapshots' do
-      with_tmp_repo do
-        response = @repo.snapshots.get
+      with_tmp_repo do |repo|
+        response = repo.snapshots.get
         assert_equal [], response["snapshots"]
-        response = @repo.snapshot.get
-        assert_equal [], response["snapshots"]
-        assert_equal false, @repo.snapshot('elastomer-test').exists?
+
+        create_snapshot(repo, 'test-snapshot')
+        response = repo.snapshot.get
+        assert_equal ['test-snapshot'], response["snapshots"].collect { |info| info["snapshot"] }
+
+        snapshot2 = create_snapshot(repo, 'test-snapshot2')
+        response  = repo.snapshots.get
+        snapshot_names = response["snapshots"].collect { |info| info["snapshot"] }
+        assert_includes snapshot_names, 'test-snapshot'
+        assert_includes snapshot_names, 'test-snapshot2'
       end
     end
   end

data/test/client/{scan_test.rb → scroller_test.rb}

@@ -1,9 +1,9 @@
 require File.expand_path('../../test_helper', __FILE__)
 
-describe Elastomer::Client::Scan do
+describe Elastomer::Client::Scroller do
 
   before do
-    @name  = 'elastomer-scan-test'
+    @name  = 'elastomer-scroller-test'
     @index = $client.index(@name)
 
     unless @index.exists?
@@ -14,14 +14,16 @@ describe Elastomer::Client::Scan do
             :_source => { :enabled => true }, :_all => { :enabled => false },
             :properties => {
               :message => { :type => 'string', :analyzer => 'standard' },
-              :author  => { :type => 'string', :index => 'not_analyzed' }
+              :author  => { :type => 'string', :index => 'not_analyzed' },
+              :sorter  => { :type => 'integer' }
             }
           },
           :book => {
             :_source => { :enabled => true }, :_all => { :enabled => false },
             :properties => {
               :title  => { :type => 'string', :analyzer => 'standard' },
-              :author => { :type => 'string', :index => 'not_analyzed' }
+              :author => { :type => 'string', :index => 'not_analyzed' },
+              :sorter  => { :type => 'integer' }
             }
           }
         }
@@ -31,6 +33,10 @@ describe Elastomer::Client::Scan do
     end
   end
 
+  after do
+    @index.delete if @index.exists?
+  end
+
   it 'scans over all documents in an index' do
     scan = @index.scan '{"query":{"match_all":{}}}', :size => 10
 
@@ -64,17 +70,30 @@ describe Elastomer::Client::Scan do
     assert_equal 1, counts['book']
   end
 
+  it 'scrolls and sorts over all documents' do
+    scroll = @index.scroll({
+      :query => {:match_all => {}},
+      :sort => {:sorter => {:order => :asc}}
+    }, :type => 'tweet')
+
+    tweets = []
+    scroll.each_document { |h| tweets << h['_id'].to_i }
+
+    expected = (0...50).to_a.reverse
+    assert_equal expected, tweets
+  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'
+        b.index %Q({"author":"pea53","message":"this is tweet number #{num}","sorter":#{50-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'
+        b.index %Q({"author":"Pratchett","title":"DiscWorld Book #{num}","sorter":#{25-num}}), :_id => num, :_type => 'book'
       }
     end
     h['items'].each {|item| assert_bulk_index(item) }

data/test/client/snapshot_test.rb

@@ -6,58 +6,53 @@ describe Elastomer::Client::Snapshot do
     before do
       @index_name = 'elastomer-snapshot-test-index'
       @index = $client.index(@index_name)
-      @repo_name = 'elastomer-snapshot-test'
       @name = 'elastomer-test'
-      @repo = $client.repository(@repo_name)
-      @snapshot = $client.snapshot(@repo_name, @name)
-      @repo.delete if @repo.exists?
-      # No need to delete snapshots because each with_tmp_repo location is unique
     end
 
     after do
-      @repo.delete if @repo.exists?
       @index.delete if @index.exists?
     end
 
     it 'determines if a snapshot exists' do
-      with_tmp_repo do
-        assert_equal false, @snapshot.exists?
-        assert_equal false, @snapshot.exist?
-        @snapshot.create({}, :wait_for_completion => true)
-        assert_equal true, @snapshot.exist?
+      with_tmp_repo do |repo|
+        snapshot = repo.snapshot(@name)
+        assert_equal false, snapshot.exists?
+        assert_equal false, snapshot.exist?
+        snapshot.create({}, :wait_for_completion => true)
+        assert_equal true, snapshot.exist?
       end
     end
 
     it 'creates snapshots' do
-      with_tmp_repo do
-        response = @snapshot.create({}, :wait_for_completion => true)
+      with_tmp_repo do |repo|
+        response = repo.snapshot(@name).create({}, :wait_for_completion => true)
         assert_equal @name, response["snapshot"]["snapshot"]
       end
     end
 
     it 'creates snapshots with options' do
       @index.create(:number_of_shards => 1, :number_of_replicas => 0)
-      with_tmp_repo do
-        response = @snapshot.create({:indices => [@index_name]}, :wait_for_completion => true)
+      with_tmp_repo do |repo|
+        response = repo.snapshot(@name).create({:indices => [@index_name]}, :wait_for_completion => true)
         assert_equal [@index_name], response["snapshot"]["indices"]
         assert_equal 1, response["snapshot"]["shards"]["total"]
       end
     end
 
     it 'gets snapshot info for one and all' do
-      with_tmp_snapshot do
-        response = @snapshot.get
-        assert_equal @name, response["snapshots"][0]["snapshot"]
-        response = @repo.snapshots.get
-        assert_equal @name, response["snapshots"][0]["snapshot"]
+      with_tmp_snapshot do |snapshot, repo|
+        response = snapshot.get
+        assert_equal snapshot.name, response["snapshots"][0]["snapshot"]
+        response = repo.snapshots.get
+        assert_equal snapshot.name, response["snapshots"][0]["snapshot"]
       end
     end
 
     it 'gets snapshot status for one and all' do
       @index.create(:number_of_shards => 1, :number_of_replicas => 0)
-      with_tmp_repo do
-        @snapshot.create({:indices => [@index_name]}, :wait_for_completion => true)
-        response = @snapshot.status
+      with_tmp_repo do |repo|
+        repo.snapshot(@name).create({:indices => [@index_name]}, :wait_for_completion => true)
+        response = repo.snapshot(@name).status
         assert_equal 1, response["snapshots"][0]["shards_stats"]["total"]
       end
     end
@@ -65,10 +60,12 @@ describe Elastomer::Client::Snapshot do
     it 'gets status of snapshots in progress' do
       # we can't reliably get status of an in-progress snapshot in tests, so
       # check for an empty result instead
-      response = @repo.snapshots.status
-      assert_equal [], response["snapshots"]
-      response = $client.snapshot.status
-      assert_equal [], response["snapshots"]
+      with_tmp_repo do |repo|
+        response = repo.snapshots.status
+        assert_equal [], response["snapshots"]
+        response = $client.snapshot.status
+        assert_equal [], response["snapshots"]
+      end
     end
 
     it 'disallows nil repo name with non-nil snapshot name' do
@@ -77,8 +74,8 @@ describe Elastomer::Client::Snapshot do
     end
 
     it 'deletes snapshots' do
-      with_tmp_snapshot do
-        response = @snapshot.delete
+      with_tmp_snapshot do |snapshot|
+        response = snapshot.delete
         assert_equal true, response["acknowledged"]
       end
     end
@@ -86,25 +83,38 @@ describe Elastomer::Client::Snapshot do
     it 'restores snapshots' do
       @index.create(:number_of_shards => 1, :number_of_replicas => 0)
       wait_for_index(@index_name)
-      with_tmp_repo do
-        @snapshot.create({:indices => [@index_name]}, :wait_for_completion => true)
+      with_tmp_repo do |repo|
+        snapshot = repo.snapshot(@name)
+        snapshot.create({:indices => [@index_name]}, :wait_for_completion => true)
         @index.delete
-        response = @snapshot.restore({}, :wait_for_completion => true)
+        response = snapshot.restore({}, :wait_for_completion => true)
         assert_equal 1, response["snapshot"]["shards"]["total"]
       end
     end
 
-    it 'restores snapshots with options' do
-      @index.create(:number_of_shards => 1, :number_of_replicas => 0)
-      wait_for_index(@index_name)
-      with_tmp_repo do
-        @snapshot.create({:indices => [@index_name]}, :wait_for_completion => true)
-        response = @snapshot.restore({
-          :rename_pattern => @index_name,
-          :rename_replacement => "#{@index_name}-restored"
-        }, :wait_for_completion => true)
-        assert_equal ["#{@index_name}-restored"], response["snapshot"]["indices"]
-        assert_equal 1, response["snapshot"]["shards"]["total"]
+    describe "restoring to a different index" do
+      before do
+        @restored_index_name = "#{@index_name}-restored"
+        @restored_index = $client.index(@restored_index_name)
+      end
+
+      after do
+        @restored_index.delete if @restored_index.exists?
+      end
+
+      it 'restores snapshots with options' do
+        @index.create(:number_of_shards => 1, :number_of_replicas => 0)
+        wait_for_index(@index_name)
+        with_tmp_repo do |repo|
+          snapshot = repo.snapshot(@name)
+          snapshot.create({:indices => [@index_name]}, :wait_for_completion => true)
+          response = snapshot.restore({
+            :rename_pattern => @index_name,
+            :rename_replacement => @restored_index_name
+          }, :wait_for_completion => true)
+          assert_equal [@restored_index_name], response["snapshot"]["indices"]
+          assert_equal 1, response["snapshot"]["shards"]["total"]
+        end
       end
     end
   end