eson-http 0.7.0

data/test/http/index_test.rb

@@ -0,0 +1,180 @@
+require './test/test_config'
+
+context 'HTTP client quick api' do
+  helper(:node) { Node::External.instance }
+  
+  helper(:client) do
+    Eson::Client.new(:server => "http://#{node.ip}:#{node.port}",
+                     :protocol => Eson::HTTP,
+                     :plugins => [Eson::StatusHandler, Eson::ResponseParser],
+                     :logger => 'test/test.log')
+  end
+
+  context "after put request" do
+    setup do
+      client.index :doc => {"test" =>  "bar"},
+                   :type => "bar",
+                   :id => 600
+    end
+    
+    asserts("is stored in correct index") {topic["_index"]}.equals('default')
+    
+    context "get request" do
+      setup do
+        client.get :type => "bar",
+                   :id => 600
+      end
+      
+      asserts("id") { topic["_id"] }.equals("600")
+    end
+    
+    context "delete" do
+      setup do
+        client.delete :type => "bar",
+                      :id => 600
+      end
+      
+      asserts("ok") { topic["ok"] }
+    end
+    
+  end
+  
+  context "percolate" do
+    setup do
+      client.create_index :index => 'test'
+      client.index :index => '_percolator',
+                   :type => 'test',
+                   :id => 'kuku',
+                   :doc => {
+                     :query => {
+                       :match_all => { }
+                     }
+                   }
+      client.refresh
+    end
+    
+    asserts("ok") { topic["ok"] }
+    asserts("responds to percolation requests") do
+      (
+        client.percolate :index => 'test',
+                                    :type => "type1",
+                                    :doc => {
+                                      :test => "foo"
+                                    }
+      )["matches"]
+    end.equals(["kuku"])
+  end
+  
+  context "mget" do
+    setup do
+      client.create_index :index => 'mget'
+      client.index :index => "mget_test",
+                   :type => "foo",
+                   :doc => {:foo => :bar},
+                   :id => 1
+      client.index :index => "mget_test",
+                   :type => "foo",
+                   :doc => {:foo => :bar},
+                   :id => 2
+      client.refresh
+      client.mget(:index => "mget_test", :ids => [1,2])
+    end
+
+    asserts("number of docs") { topic["docs"].length }.equals(2)
+  end
+
+  unless ENV["ES_VERSION"] && ENV["ES_VERSION"] < "0.19.0"
+    context "delete_by_query" do
+      setup do
+        client.index :index => "delete_by_query",
+                     :type => "foo",
+                     :doc => {:foo => :bar}
+        client.index :index => "delete_by_query",
+                     :type => "foo",
+                     :doc => {:foo => :bar}
+        client.refresh :index => "delete_by_query"
+    
+        client.delete_by_query :index => "delete_by_query",
+                               :query => { :match_all => {} }
+      end
+    
+      asserts("no doc left") { client.search(:index => "delete_by_query")["hits"]["total"] }.equals(0)
+    end
+  end
+end
+
+context 'HTTP client verbose API' do
+  helper(:client) do
+    Eson::HTTP::Client.new(:auto_call => false)
+  end
+  
+  context "returns request objects" do
+    setup do 
+      client.index
+    end
+    
+    asserts_topic("is an Index request").kind_of?(Eson::HTTP::Index)
+  end
+
+  context "#msearch without block" do
+    setup do
+      msearch = client.msearch
+      msearch.search :index => 'test',
+                     :type => 'kuku',
+                     :query => {
+                       :match_all => { }
+                     }
+      msearch.search :index => 'test',
+                     :query => {
+                       :match_all => { }
+                     }
+      msearch.search :index => 'test',
+                     :search_type => 'count',
+                     :query => {
+                       :match_all => { }
+                     }
+      msearch
+    end
+
+    asserts(:source).equals(<<-JSON)
+{"indices":["test"],"types":["kuku"]}
+{"query":{"match_all":{}}}
+{"indices":["test"]}
+{"query":{"match_all":{}}}
+{"indices":["test"],"search_type":"count"}
+{"query":{"match_all":{}}}
+JSON
+  end
+
+  context "#msearch with block" do
+    setup do
+      client.msearch :index => "foo", :type => "bar" do |s|
+        s.search :index => 'test',
+                 :type => 'kuku',
+                 :query => {
+                   :match_all => { }
+                 }
+        s.search :index => 'test',
+                 :query => {
+                   :match_all => { }
+                 }
+        s.search :index => 'test',
+                 :search_type => 'count',
+                 :query => {
+                   :match_all => { }
+                 }
+      end
+    end
+
+    asserts(:source).equals(<<-JSON)
+{"indices":["test"],"types":["kuku"]}
+{"query":{"match_all":{}}}
+{"indices":["test"]}
+{"query":{"match_all":{}}}
+{"indices":["test"],"search_type":"count"}
+{"query":{"match_all":{}}}
+JSON
+
+    asserts(:fill).equals(Addressable::URI.parse("foo/bar/_msearch"))
+  end
+end

data/test/http/indices/basics_test.rb

@@ -0,0 +1,257 @@
+require './test/test_config'
+
+context 'HTTP client' do
+  helper(:node) { Node::External.instance }
+  
+  helper(:client) do
+    Eson::Client.new(:server => "http://#{node.ip}:#{node.port}", 
+                              :protocol => Eson::HTTP, 
+                              :plugins => [Eson::StatusHandler, Eson::ResponseParser], 
+                              :logger => 'test/test.log',
+                              :auth => ['Aladdin', 'open sesame'])
+  end
+  
+  context "http auth" do
+    asserts {
+      request = client.search({}, false)
+      request.base_resource.headers['Authorization']
+    }.equals('Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==')
+  end
+  
+  context "missing index" do
+    asserts {
+      client.refresh
+      client.get :index => "missing", :type => "foo", :id => 1
+    }.raises(Eson::IndexNotFoundError)
+  end
+  
+  context "missing handler" do
+    asserts {
+       client.get :index => "missing"
+    }.raises(Eson::Error)
+  end
+  
+  # deactivated, because it is behaving flakey...
+  #context "with an existing index" do
+  #  setup do
+  #    client.create_index :index => "existing"
+  #    client.refresh
+  #  end
+  #  
+  #  asserts {
+  #    client.get :index => "existing", :type => "foo", :id => 81923123
+  #  }.raises(Eson::NotFoundError)
+  #end
+  
+  context "delete index" do
+    setup do
+      client.delete_index :index => "for_deletion"
+    end
+    
+    asserts("ok") { topic["ok"] }
+  end
+  
+  context "create index" do
+    setup do
+      client.create_index :index => "for_creation"
+    end
+    
+    asserts("ok") { topic["ok"] }
+  end
+  
+  context "create with settings and mappings" do
+    setup do
+      client.create_index :index => "for_creation_with_settings_and_mappings",
+                          :settings => {
+                            :index => {
+                              :number_of_shards => 1
+                            }
+                          },
+                          :mappings => {
+                            :type1 => {
+                              :_source => { :enabled => false },
+                              :properties => {
+                                :field1 => { :type => "string", :index => "not_analyzed" }
+                              }
+                            }
+                          }
+    end
+    
+    asserts("ok") { topic["ok"] }
+    asserts("settings can be retrieved") do
+      (
+        client.get_settings :index => "for_creation_with_settings_and_mappings"
+      )["for_creation_with_settings_and_mappings"]["settings"]["index.number_of_shards"]
+    end
+  end
+  
+  context "template creation" do
+    setup do
+      result = client.put_template :name => 'foo',
+                                   :template => 'foo*',
+                                   :settings => {
+                                     :index => {
+                                       :number_of_shards => 1
+                                     }
+                                   },
+                                   :mappings => {
+                                     :type1 => {
+                                       :_source => { :enabled => false },
+                                       :properties => {
+                                         :field1 => { :type => "string", :index => "not_analyzed" }
+                                       }
+                                     }
+                                   }
+      sleep 0.5
+      result
+    end
+    
+    asserts("ok") { topic["ok"] }
+    
+    context "get template" do
+      setup do
+        client.get_template :name => 'foo'
+      end
+      
+      asserts("returns correct template") { topic["foo"] }
+    end
+    
+    context "delete template" do
+      setup do
+        client.delete_template :name => 'foo'
+      end
+      
+      asserts("ok") { topic["ok"] }
+    end
+  end
+  
+  context "aliases" do
+    setup do
+      client.create_index :index => "abc"
+      client.create_index :index => "def"
+      client.aliases do |r|
+        r.add "abc", "alias"
+        r.add "def", "alias"
+      end
+    end
+    
+    asserts("ok") { topic["ok"] }
+    asserts("can be queried") do
+      client.status :index => "alias"
+    end    
+  end
+  
+  context "refresh" do
+    setup do
+      client.refresh :index => "default"
+    end
+    
+    asserts("ok") { topic["ok"] }
+  end
+  
+  context "snapshot" do
+    setup do
+      client.snapshot :index => "default"
+    end
+    
+    asserts("ok") { topic["ok"] }
+  end
+  
+  context "clear_cache" do
+    setup do
+      client.clear_cache :index => "default",
+                         :filter => true
+    end
+    
+    asserts("ok") { topic["ok"] }
+  end
+  
+  context "flush" do
+    setup do
+      client.flush :index => "default"
+    end
+    
+    asserts("ok") { topic["ok"] }
+  end
+  
+  context "optimize" do
+    setup do
+      client.optimize :index => "default"
+    end
+    
+    asserts("ok") { topic["ok"] }
+  end
+  
+  context "close index" do
+    setup do
+      client.create_index :index => 'for_closing'
+      client.close_index :index => 'for_closing'
+      client.refresh
+    end
+    
+    asserts("ok") { topic["ok"] }
+    asserts("cannot be requested") { (client.status :index => 'for_closing')["indices"] }.equals({})
+  end
+  
+  context "open index" do
+    setup do
+      client.create_index :index => 'for_reopening'
+      client.close_index :index => 'for_reopening'
+      client.open_index :index => 'for_reopening'
+    end
+    
+    asserts("ok") { topic["ok"] }
+    asserts("can be requested") { (client.status :index => 'for_reopening')["indices"]['for_reopening'] }
+  end
+  
+  context "put mapping" do
+    setup do
+      client.create_index :index => 'mappings'
+      result = client.put_mapping :index => 'mappings',
+                         :type => 'type1',
+                         :mapping => {
+                           :type1 => {
+                             :_source => { :enabled => false },
+                             :properties => {
+                               :field1 => { :type => "string", :index => "not_analyzed" }
+                             }
+                           }
+                         }
+      sleep 0.5
+      result
+    end
+    
+    asserts("ok") { topic["ok"] }
+    asserts("mapping can be retrieved") do
+      (
+        client.get_mapping :index => "mappings", 
+                           :type => 'type1'
+      )['type1']['_source']['enabled']
+    end.equals(false)
+  end
+  
+  context "exists?" do
+    setup do
+      client.exists? :index => 'does_not_exist_at_all'
+    end
+
+    asserts { topic }.equals(false)
+  end
+  
+  context "index stats" do
+    setup do
+      client.index_stats :index => 'default'
+    end
+
+    asserts { topic["ok"] }.equals(true)
+  end
+  
+  context "index segments" do
+     setup do
+       client.segments :index => 'default'
+     end
+
+     asserts { topic["ok"] }.equals(true)
+   end
+
+end

data/test/http/query_test.rb

@@ -0,0 +1,70 @@
+require './test/test_config'
+
+context 'HTTP client quickapi' do
+  helper(:node) { Node::External.instance }
+
+  helper(:client) do
+    Eson::Client.new(:server => "http://#{node.ip}:#{node.port}",
+                              :protocol => Eson::HTTP,
+                              :plugins => [Eson::StatusHandler, Eson::ResponseParser],
+                              :logger => 'test/test.log')
+  end
+
+  setup do
+    #client.create_index :index => "default"
+    client.refresh
+  end
+
+  context "query" do
+    setup do
+      client.query :query => {
+        "term" => { "user" => "kimchy" }
+      }
+    end
+
+    asserts("has hits") { topic['hits']['total'] }
+    asserts("has no failures") { topic["_shards"]["failures"]}.equals(nil)
+  end
+
+  context "count query" do
+    setup do 
+      client.count :query => {
+        :match_all => { }
+      }
+    end
+
+    asserts("has hits") { topic["count"] }
+    asserts("has no failures") { topic["_shards"]["failures"]}.equals(nil)
+  end
+
+  context "mlt query" do
+    setup do
+      client.index :doc => {"test" =>  "bar"}, 
+                   :type => "bar", 
+                   :id => 200
+
+      client.more_like_this :index => 'default', :type => "bar", :id => 200
+    end
+
+    asserts("has hits") { topic["timed_out"] }.equals(false)
+    asserts("has no failures") { topic["_shards"]["failures"]}.equals(nil)
+  end
+
+  context "filtered queries" do
+    setup do
+      client.query :query => {
+                     "term" => { "name.first" => "shay" }
+                   },
+                   :filter => {
+                     "terms" => {
+                       "name.last" => ["banon", "kimchy"],
+                       "_name" => "test"
+                     }
+                   }
+    end
+
+    asserts("ok") { topic["hits"]["total"] }.equals(0)
+    asserts("has no failures") { topic["_shards"]["failures"]}.equals(nil)
+  end
+
+end