elastomer-client 0.3.1

data/test/client/stubbed_client_tests.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe 'stubbed client tests' do
+  before do
+    @stubs  = Faraday::Adapter.lookup_middleware(:test)::Stubs.new
+    @client = Elastomer::Client.new :adapter => [:test, @stubs]
+  end
+
+  describe Elastomer::Client::Cluster do
+    it 'reroutes shards' do
+      @stubs.post '/_cluster/reroute?dry_run=true' do |env|
+        assert_match %r/^\{"commands":\[\{"move":\{[^\{\}]+\}\}\]\}$/, env[:body]
+        [200, {'Content-Type' => 'application/json'}, '{"acknowledged" : true}']
+      end
+
+      commands = { :move => { :index => 'test', :shard => 0, :from_node => 'node1', :to_node => 'node2' }}
+      h = @client.cluster.reroute commands, :dry_run => true
+      assert_acknowledged h
+    end
+
+    it 'performs a shutdown of the cluster' do
+      @stubs.post('/_shutdown') { [200, {'Content-Type' => 'application/json'}, '{"cluster_name":"elasticsearch"}'] }
+      h = @client.cluster.shutdown
+      assert_equal "elasticsearch", h['cluster_name']
+    end
+  end
+
+  describe Elastomer::Client::Nodes do
+    it 'performs a shutdown of the node(s)' do
+      @stubs.post('/_cluster/nodes/_shutdown')       { [200, {'Content-Type' => 'application/json'}, '{"nodes":{"1":{"name":"Node1"}}}'] }
+      @stubs.post('/_cluster/nodes/node2/_shutdown') { [200, {'Content-Type' => 'application/json'}, '{"nodes":{"2":{"name":"Node2"}}}'] }
+
+      h = @client.nodes.shutdown
+      assert_equal "Node1", h['nodes']['1']['name']
+
+      h = @client.nodes('node2').shutdown
+      assert_equal 'Node2', h['nodes']['2']['name']
+    end
+  end
+end

data/test/client/template_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe Elastomer::Client::Cluster do
+
+  before do
+    @name = 'elastomer-template-test'
+    @template = $client.template @name
+  end
+
+  after do
+    @template.delete if @template.exists?
+  end
+
+  it 'creates a template' do
+    assert !@template.exists?, 'the template should not exist'
+
+    @template.create({
+      :template => 'test-elastomer*',
+      :settings => { :number_of_shards => 3 },
+      :mappings => {
+        :doco => { :_source => { :enabled => false }}
+      }
+    })
+
+    assert @template.exists?, ' we now have a cluster-test template'
+
+    template = @template.get
+    assert_equal [@name], template.keys
+    assert_equal 'test-elastomer*', template[@name]['template']
+    assert_equal '3', template[@name]['settings']['index.number_of_shards']
+  end
+
+end

data/test/client/warmer_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe Elastomer::Client::Warmer do
+  before do
+    @name  = 'elastomer-warmer-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' }
+            }
+          }
+        }
+      )
+      wait_for_index(@name)
+    end
+  end
+
+  after do
+    @index.delete if @index.exists?
+  end
+
+  it 'creates warmers' do
+    h = @index.warmer('test1').create(:query => { :match_all => {}})
+    assert_acknowledged h
+  end
+
+  it 'deletes warmers' do
+    @index.warmer('test1').create(:query => { :match_all => {}})
+
+    h = @index.warmer('test1').delete
+    assert_acknowledged h
+  end
+
+  it 'gets warmers' do
+    body = { "query" => {"match_all" => {}}}
+    @index.warmer('test1').create(body)
+
+    h = @index.warmer('test1').get
+    assert_equal body, h[@name]["warmers"]["test1"]["source"]
+  end
+
+  it 'knows when warmers exist' do
+    assert_equal false, @index.warmer('test1').exists?
+    assert_equal false, @index.warmer('test1').exist?
+
+    h = @index.warmer('test1').create(:query => { :match_all => {}})
+    assert_equal true, @index.warmer('test1').exists?
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,86 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe Elastomer::Client do
+
+  it 'uses the adapter specified at creation' do
+    c = Elastomer::Client.new(:adapter => :test)
+    assert_includes c.connection.builder.handlers, Faraday::Adapter::Test
+  end
+
+  it "use Faraday's default adapter if none is specified" do
+    c = Elastomer::Client.new
+    adapter = Faraday::Adapter.lookup_middleware(Faraday.default_adapter)
+    assert_includes c.connection.builder.handlers, adapter
+  end
+
+  it 'uses the same connection for all requests' do
+    c = $client.connection
+    assert_same c, $client.connection
+  end
+
+  it 'raises an error for unknown HTTP request methods' do
+    assert_raises(ArgumentError) { $client.request :foo, '/', {} }
+  end
+
+  it 'raises an error on 4XX responses with an `error` field' do
+    begin
+      $client.get '/non-existent-index/_search?q=*:*'
+      assert false, 'exception was not raised when it should have been'
+    rescue Elastomer::Client::Error => err
+      assert_equal 404, err.status
+      assert_equal 'IndexMissingException[[non-existent-index] missing]', err.message
+    end
+  end
+
+  it 'handles path expansions' do
+    uri = $client.expand_path '/{foo}/{bar}', :foo => '_cluster', :bar => 'health'
+    assert_equal '/_cluster/health', uri
+
+    uri = $client.expand_path '{/foo}{/baz}{/bar}', :foo => '_cluster', :bar => 'state'
+    assert_equal '/_cluster/state', uri
+  end
+
+  it 'handles query parameters' do
+    uri = $client.expand_path '/_cluster/health', :level => 'shards'
+    assert_equal '/_cluster/health?level=shards', uri
+  end
+
+  it 'validates path expansions' do
+    assert_raises(ArgumentError) {
+      $client.expand_path '/{foo}/{bar}', :foo => '_cluster', :bar => nil
+    }
+
+    assert_raises(ArgumentError) {
+      $client.expand_path '/{foo}/{bar}', :foo => '_cluster', :bar => ''
+    }
+  end
+
+  describe 'when validating parameters' do
+    it 'rejects nil values' do
+      assert_raises(ArgumentError) { $client.assert_param_presence nil }
+    end
+
+    it 'rejects empty strings' do
+      assert_raises(ArgumentError) { $client.assert_param_presence "" }
+      assert_raises(ArgumentError) { $client.assert_param_presence " " }
+      assert_raises(ArgumentError) { $client.assert_param_presence " \t \r \n " }
+    end
+
+    it 'rejects empty strings and nil values found in arrays' do
+      assert_raises(ArgumentError) { $client.assert_param_presence ['foo', nil, 'bar'] }
+      assert_raises(ArgumentError) { $client.assert_param_presence ['baz', " \t \r \n "] }
+    end
+
+    it 'strips whitespace from strings' do
+      assert_equal 'foo', $client.assert_param_presence("  foo  \t")
+    end
+
+    it 'joins array values into a string' do
+      assert_equal 'foo,bar', $client.assert_param_presence(%w[foo bar])
+    end
+
+    it 'flattens arrays' do
+      assert_equal 'foo,bar,baz,buz', $client.assert_param_presence(["  foo  \t", %w[bar baz buz]])
+    end
+  end
+end

data/test/core_ext/time_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'elastomer/core_ext/time'
+
+describe 'JSON conversions for Time' do
+  before do
+    @name  = 'elastomer-time-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', :index => 'not_analyzed' },
+              :created_at => { :type => 'date' }
+            }
+          }
+        }
+
+      wait_for_index(@name)
+    end
+
+    @docs = @index.docs
+  end
+
+  after do
+    @index.delete if @index.exists?
+  end
+
+  it 'generates ISO8601 formatted time strings' do
+    time = Time.utc(2013, 5, 3, 10, 1, 31)
+    assert_equal '"2013-05-03T10:01:31Z"', MultiJson.encode(time)
+  end
+
+  it 'indexes time fields' do
+    time = Time.utc(2013, 5, 3, 10, 1, 31)
+    h = @docs.index({:title => 'test document', :created_at => time}, :type => 'doc1')
+
+    assert_created(h)
+
+    doc = @docs.get(:type => 'doc1', :id => h['_id'])
+    assert_equal '2013-05-03T10:01:31Z', doc['_source']['created_at']
+  end
+end

data/test/middleware/encode_json_test.rb

@@ -0,0 +1,53 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe Elastomer::Middleware::EncodeJson do
+  let(:middleware) { Elastomer::Middleware::EncodeJson.new(lambda {|env| env})}
+
+  def process(body, content_type = nil)
+    env = { :body => body, :request_headers => Faraday::Utils::Headers.new }
+    env[:request_headers]['content-type'] = content_type if content_type
+    middleware.call(env)
+  end
+
+  it 'handles no body' do
+    result = process(nil)
+    assert_nil result[:body]
+    assert_nil result[:request_headers]['content-type']
+  end
+
+  it 'handles empty body' do
+    result = process('')
+    assert_empty result[:body]
+    assert_nil result[:request_headers]['content-type']
+  end
+
+  it 'handles string body' do
+    result = process('{"a":1}')
+    assert_equal '{"a":1}', result[:body]
+    assert_equal 'application/json', result[:request_headers]['content-type']
+  end
+
+  it 'handles object body' do
+    result = process({:a => 1})
+    assert_equal '{"a":1}', result[:body]
+    assert_equal 'application/json', result[:request_headers]['content-type']
+  end
+
+  it 'handles empty object body' do
+    result = process({})
+    assert_equal '{}', result[:body]
+    assert_equal 'application/json', result[:request_headers]['content-type']
+  end
+
+  it 'handles object body with json type' do
+    result = process({:a => 1}, 'application/json; charset=utf-8')
+    assert_equal '{"a":1}', result[:body]
+    assert_equal 'application/json; charset=utf-8', result[:request_headers]['content-type']
+  end
+
+  it 'handles object body with incompatible type' do
+    result = process({:a => 1}, 'application/xml; charset=utf-8')
+    assert_equal({:a => 1}, result[:body])
+    assert_equal 'application/xml; charset=utf-8', result[:request_headers]['content-type']
+  end
+end

data/test/middleware/opaque_id_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe Elastomer::Middleware::OpaqueId do
+
+  before do
+    stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+      stub.get('/_cluster/health') { |env|
+        [ 200,
+
+          { 'X-Opaque-Id'    => env[:request_headers]['X-Opaque-Id'],
+            'Content-Type'   => 'application/json; charset=UTF-8',
+            'Content-Length' => '49' },
+
+          %q[{"cluster_name":"elasticsearch","status":"green"}]
+        ]
+      }
+
+      stub.get('/_cluster/state') { |env|
+        [ 200, {'X-Opaque-Id' => "00000000-0000-0000-0000-000000000000"}, %q[{"foo":"bar"}] ]
+      }
+    end
+
+    opts = $client_params.merge \
+        :opaque_id => true,
+        :adapter   => [:test, stubs]
+
+    @client = Elastomer::Client.new opts
+  end
+
+  it 'generates an "X-Opaque-Id" header' do
+    health = @client.cluster.health
+    assert_equal({"cluster_name" => "elasticsearch", "status" => "green"}, health)
+  end
+
+  it 'raises an exception on conflicting headers' do
+    assert_raises(Elastomer::Client::OpaqueIdError) { @client.cluster.state }
+  end
+
+end

data/test/middleware/parse_json_test.rb

@@ -0,0 +1,54 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe Elastomer::Middleware::ParseJson do
+  let(:middleware) { Elastomer::Middleware::ParseJson.new(lambda {|env| Faraday::Response.new(env)})}
+  let(:headers) { Hash.new }
+
+  def process(body, content_type = nil)
+    env = { :body => body, :response_headers => Faraday::Utils::Headers.new(headers) }
+    env[:response_headers]['content-type'] = content_type if content_type
+    middleware.call(env)
+  end
+
+  it "doesn't change nil body" do
+    response = process(nil)
+    assert_nil response.body
+  end
+
+  it 'nullifies empty body' do
+    response = process("")
+    assert_nil response.body
+  end
+
+  it 'nullifies blank body' do
+    response = process(" ")
+    assert_nil response.body
+  end
+
+  it 'parses json body with empty type' do
+    response = process('{"a":1}')
+    assert_equal({'a' => 1}, response.body)
+  end
+
+  it 'parses json body of correct type' do
+    response = process('{"a":1}', 'application/json; charset=utf-8')
+    assert_equal({'a' => 1}, response.body)
+  end
+
+  it 'ignores json body if incorrect type' do
+    response = process('{"a":1}', 'application/xml; charset=utf-8')
+    assert_equal('{"a":1}', response.body)
+  end
+
+  it 'chokes on invalid json' do
+    assert_raises(Faraday::Error::ParsingError) { process '{!'      }
+    assert_raises(Faraday::Error::ParsingError) { process 'invalid' }
+
+    # surprisingly these are all valid according to MultiJson
+    #
+    # assert_raises(Faraday::Error::ParsingError) { process '"a"'  }
+    # assert_raises(Faraday::Error::ParsingError) { process 'true' }
+    # assert_raises(Faraday::Error::ParsingError) { process 'null' }
+    # assert_raises(Faraday::Error::ParsingError) { process '1'    }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,94 @@
+require 'rubygems' unless defined? Gem
+require 'bundler'
+Bundler.require(:default, :development)
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/test/"
+    add_filter "/vendor/"
+  end
+end
+
+require 'minitest/spec'
+require 'minitest/autorun'
+
+# push the lib folder onto the load path
+$LOAD_PATH.unshift 'lib'
+require 'elastomer/client'
+
+# we are going to use the same client instance everywhere!
+# the client should always be stateless
+$client_params = {
+  :port => ENV['BOXEN_ELASTICSEARCH_PORT'] || 9200,
+  :read_timeout => 2,
+  :open_timeout => 1,
+  :opaque_id => true
+}
+$client = Elastomer::Client.new $client_params
+
+# ensure we have an ElasticSearch server to test with
+raise "No server available at #{$client.url}" unless $client.available?
+
+# remove any lingering test indices from the cluster
+MiniTest::Unit.after_tests do
+  $client.cluster.indices.keys.each do |name|
+    next unless name =~ /^elastomer-/i
+    $client.index(name).delete
+  end
+
+  $client.cluster.templates.keys.each do |name|
+    next unless name =~ /^elastomer-/i
+    $client.template(name).delete
+  end
+end
+
+# add custom assertions
+require File.expand_path('../assertions', __FILE__)
+
+# require 'elastomer/notifications'
+# require 'pp'
+
+# ActiveSupport::Notifications.subscribe('request.client.elastomer') do |name, start_time, end_time, transaction_id, payload|
+#   $stdout.puts '-'*100
+#   #$stdout.puts "-- #{payload[:action].inspect}"
+#   pp payload #if payload[:action].nil?
+# end
+
+# Wait for an index to be created. Since index creation requests return
+# before the index is actually ready to receive documents, one needs to wait
+# until the cluster status recovers before proceeding.
+#
+#   name   - The index name to wait for
+#   status - The status to wait for. Defaults to yellow. Yellow is the
+#            preferred status for tests, because it waits for at least one
+#            shard to be active, but doesn't wait for all replicas. Single
+#            node clusters will never achieve green status with the default
+#            setting of 1 replica.
+#
+# Returns the cluster health response.
+# Raises Elastomer::Client::TimeoutError if requested status is not achieved
+# within 5 seconds.
+def wait_for_index(name, status='yellow')
+  $client.cluster.health(
+    :index           => name,
+    :wait_for_status => status,
+    :timeout         => '5s'
+  )
+end
+
+# Elasticsearch 1.0 changed some request formats in a non-backward-compatible
+# way. Some tests need to know what version is running to structure requests
+# as expected.
+#
+# Returns true if Elasticsearch version is 1.x.
+def es_version_1_x?
+  $client.semantic_version >= '1.0.0'
+end
+
+# Elasticsearch 1.2 removed support for gateway snapshots.
+#
+# Returns true if Elasticsearch version supports gateway snapshots.
+def es_version_supports_gateway_snapshots?
+  $client.semantic_version <= '1.2.0'
+end