elasticsearch-transport 0.4.0 → 0.4.2

data/README.md

@@ -1,11 +1,11 @@
-# Elasticsearch::Client
+# Elasticsearch::Transport
 
 **This library is part of the [`elasticsearch-ruby`](https://github.com/elasticsearch/elasticsearch-ruby/) package;
 please refer to it, unless you want to use this library standalone.**
 
 ----
 
-The `elasticsearch-client` library provides a Ruby client for connecting
+The `elasticsearch-transport` library provides a low-level Ruby client for connecting
 to an [Elasticsearch](http://elasticsearch.org) cluster.
 
 It handles connecting to multiple nodes in the cluster, rotating across connections,
@@ -31,16 +31,16 @@ Features overview:
 
 Install the package from [Rubygems](https://rubygems.org):
 
-    gem install elasticsearch-client
+    gem install elasticsearch-transport
 
 To use an unreleased version, either add it to your `Gemfile` for [Bundler](http://gembundler.com):
 
-    gem 'elasticsearch-client', git: 'git://github.com/elasticsearch/elasticsearch-ruby.git'
+    gem 'elasticsearch-transport', git: 'git://github.com/elasticsearch/elasticsearch-ruby.git'
 
 or install it from a source code checkout:
 
     git clone https://github.com/elasticsearch/elasticsearch-ruby.git
-    cd elasticsearch-ruby/elasticsearch-client
+    cd elasticsearch-ruby/elasticsearch-transport
     bundle install
     rake install
 
@@ -49,12 +49,14 @@ or install it from a source code checkout:
 In the simplest form, connect to Elasticsearch running on <http://localhost:9200>
 without any configuration:
 
-    require 'elasticsearch/client'
+    require 'elasticsearch/transport'
 
     client = Elasticsearch::Client.new
     response = client.perform_request 'GET', '_cluster/health'
     # => #<Elasticsearch::Transport::Transport::Response:0x007fc5d506ce38 @status=200, @body={ ... } >
 
+Full documentation is available at <http://rubydoc.info/gems/elasticsearch-transport>.
+
 ## Configuration
 
 The client supports many configurations options for setting up and managing connections,
@@ -78,9 +80,13 @@ Instead of Strings, you can pass host information as an array of Hashes:
 
     Elasticsearch::Client.new hosts: [ { host: 'myhost1', port: 8080 }, { host: 'myhost2', port: 8080 } ]
 
+Scheme, HTTP authentication credentials and URL prefixes are handled automatically:
+
+    Elasticsearch::Client.new url: 'https://username:password@api.server.org:4430/search'
+
 ### Logging
 
-To log requests and responses to standard output with the default logger (an instance of Ruby's {::Logger}) class):
+To log requests and responses to standard output with the default logger (an instance of Ruby's {::Logger} class):
 
     Elasticsearch::Client.new log: true
 
@@ -163,7 +169,7 @@ and only when these are not be available, will use the rest:
       include Elasticsearch::Transport::Transport::Connections::Selector::Base
 
       def select(options={})
-        connections.reject do |c|
+        connections.select do |c|
           # Try selecting the nodes with a `rack_id:x1` attribute first
           c.host[:attributes] && c.host[:attributes][:rack_id] == 'x1'
         end.sample || connections.to_a.sample
@@ -201,7 +207,9 @@ You can also use a [_Curb_](https://rubygems.org/gems/curb) based transport impl
 
 It's possible to customize the _Curb_ instance by passing a block to the constructor as well:
 
-    configuration = lambda { |c| c.verbose = true }
+    configuration = lambda do |c|
+      c.verbose = true
+    end
 
     transport = Elasticsearch::Transport::Transport::HTTP::Curb.new \
       hosts: [ { host: 'localhost', port: '9200' } ],
@@ -209,6 +217,17 @@ It's possible to customize the _Curb_ instance by passing a block to the constru
 
     client = Elasticsearch::Client.new transport: transport
 
+Instead of passing the transport to the constructor, you can inject it at run time:
+
+    faraday_client = Elasticsearch::Transport::Transport::HTTP::Faraday.new \
+          hosts: [ { host: '33.33.33.10', port: '443', user: 'USERNAME', password: 'PASSWORD', scheme: 'https' } ],
+          & lambda { |f| f.instance_variable_set :@ssl, { verify: false }
+                         f.options[:ssl] = { verify: false }
+                         f.adapter :excon }
+
+    client = Elasticsearch::Client.new
+    client.transport = faraday_client
+
 You can write your own transport implementation easily, by including the
 {Elasticsearch::Transport::Transport::Base} module, implementing the required contract,
 and passing it to the client as the `transport_class` parameter. All the arguments
@@ -228,9 +247,9 @@ and passing it to the client as the `serializer_class` or `serializer` parameter
 For local development, clone the repository and run `bundle install`. See `rake -T` for a list of
 available Rake tasks for running tests, generating documentation, starting a testing cluster, etc.
 
-Bug fixes and features must be accompanying by unit tests. Integration tests are written in Ruby 1.9 syntax.
+Bug fixes and features must be covered by unit tests. Integration tests are written in Ruby 1.9 syntax.
 
-Github's pull requests and issues are used to send code contributions and bug reports.
+Github's pull requests and issues are used to communicate, send bug reports and code contributions.
 
 ## The Architecture
 

data/Rakefile

@@ -8,7 +8,19 @@ task :test    => 'test:unit'
 
 require 'rake/testtask'
 namespace :test do
+  task :ci_reporter do
+    ENV['CI_REPORTS'] ||= 'tmp/reports'
+    if defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
+      require 'ci/reporter/rake/test_unit'
+      Rake::Task['ci:setup:testunit'].invoke
+    else
+      require 'ci/reporter/rake/minitest'
+      Rake::Task['ci:setup:minitest'].invoke
+    end
+  end
+
   Rake::TestTask.new(:unit) do |test|
+    Rake::Task['test:ci_reporter'].invoke if ENV['CI']
     test.libs << 'lib' << 'test'
     test.test_files = FileList["test/unit/**/*_test.rb"]
     # test.verbose = true
@@ -16,16 +28,19 @@ namespace :test do
   end
 
   Rake::TestTask.new(:integration) do |test|
+    Rake::Task['test:ci_reporter'].invoke if ENV['CI']
     test.libs << 'lib' << 'test'
     test.test_files = FileList["test/integration/**/*_test.rb"]
   end
 
   Rake::TestTask.new(:all) do |test|
+    Rake::Task['test:ci_reporter'].invoke if ENV['CI']
     test.libs << 'lib' << 'test'
     test.test_files = FileList["test/unit/**/*_test.rb", "test/integration/**/*_test.rb"]
   end
 
   Rake::TestTask.new(:profile) do |test|
+    Rake::Task['test:ci_reporter'].invoke if ENV['CI']
     test.libs << 'lib' << 'test'
     test.test_files = FileList["test/profile/**/*_test.rb"]
   end
@@ -34,17 +49,15 @@ namespace :test do
     desc "Start Elasticsearch nodes for tests"
     task :start do
       $LOAD_PATH << File.expand_path('../lib', __FILE__) << File.expand_path('../test', __FILE__)
-      require 'elasticsearch/transport'
-      require 'elasticsearch/transport/extensions/test_cluster'
-      Elasticsearch::TestCluster.start
+      require 'elasticsearch/extensions/test/cluster'
+      Elasticsearch::Extensions::Test::Cluster.start
     end
 
     desc "Stop Elasticsearch nodes for tests"
     task :stop do
       $LOAD_PATH << File.expand_path('../lib', __FILE__) << File.expand_path('../test', __FILE__)
-      require 'elasticsearch/transport'
-      require 'elasticsearch/transport/extensions/test_cluster'
-      Elasticsearch::TestCluster.stop
+      require 'elasticsearch/extensions/test/cluster'
+      Elasticsearch::Extensions::Test::Cluster.stop
     end
   end
 end

data/elasticsearch-transport.gemspec

@@ -29,21 +29,31 @@ Gem::Specification.new do |s|
   s.add_development_dependency "bundler", "> 1"
   s.add_development_dependency "rake"
 
+  s.add_development_dependency "elasticsearch-extensions"
+
   s.add_development_dependency "ansi"
   s.add_development_dependency "shoulda-context"
   s.add_development_dependency "mocha"
   s.add_development_dependency "turn"
   s.add_development_dependency "yard"
   s.add_development_dependency "ruby-prof"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "ci_reporter"
 
   # Gems for testing integrations
   s.add_development_dependency "curb"
-  s.add_development_dependency "typhoeus"
+  s.add_development_dependency "typhoeus", '~> 0.6'
+
+  # Prevent unit test failures on Ruby 1.8
+  if defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
+    s.add_development_dependency "test-unit", '~> 2'
+  end
 
   if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
     s.add_development_dependency "simplecov"
     s.add_development_dependency "cane"
     s.add_development_dependency "require-prof"
+    s.add_development_dependency "coveralls"
   end
 
   s.description = <<-DESC.gsub(/^    /, '')

data/lib/elasticsearch/transport/client.rb

@@ -105,13 +105,19 @@ module Elasticsearch
         hosts = hosts_config.map do |host|
           case host
           when String
-            # TODO: Handle protocol?
-            host, port = host.split(':')
-            { :host => host, :port => port }
+            if host =~ /^[a-z]+\:\/\//
+              uri = URI.parse(host)
+              { :scheme => uri.scheme, :user => uri.user, :password => uri.password, :host => uri.host, :path => uri.path, :port => uri.port.to_s }
+            else
+              host, port = host.split(':')
+              { :host => host, :port => port }
+            end
+          when URI
+            { :scheme => host.scheme, :user => host.user, :password => host.password, :host => host.host, :path => host.path, :port => host.port.to_s }
           when Hash
             host
           else
-            raise ArgumentError, "Please pass host as a String or Hash, #{host.class} given."
+            raise ArgumentError, "Please pass host as a String, URI or Hash -- #{host.class} given."
           end
         end
 

data/lib/elasticsearch/transport/transport/base.rb

@@ -139,6 +139,19 @@ module Elasticsearch
           o = o.is_a?(String) ? o : serializer.dump(o, options)
         end
 
+        # Returns a full URL based on information from host
+        #
+        # @param host [Hash] Host configuration passed in from {Client}
+        #
+        # @api private
+        def __full_url(host)
+          url  = "#{host[:protocol]}://"
+          url += "#{host[:user]}:#{host[:password]}@" if host[:user]
+          url += "#{host[:host]}:#{host[:port]}"
+          url += "#{host[:path]}" if host[:path]
+          url
+        end
+
         # Performs a request to Elasticsearch, while handling logging, tracing, marking dead connections,
         # retrying the request and reloading the connections.
         #

data/lib/elasticsearch/transport/transport/connections/connection.rb

@@ -36,7 +36,11 @@ module Elasticsearch
           # @return [String]
           #
           def full_url(path, params={})
-            "#{host[:protocol]}://#{host[:host]}:#{host[:port]}/#{full_path(path, params)}"
+            url  = "#{host[:protocol]}://"
+            url += "#{host[:user]}:#{host[:password]}@" if host[:user]
+            url += "#{host[:host]}:#{host[:port]}"
+            url += "#{host[:path]}" if host[:path]
+            url += "/#{full_path(path, params)}"
           end
 
           # Returns the complete endpoint path with serialized parameters.

data/lib/elasticsearch/transport/transport/http/curb.rb

@@ -20,15 +20,14 @@ module Elasticsearch
               connection.connection.url = url
 
               case method
-                when 'HEAD', 'GET' then connection.connection.http method.downcase.to_sym
-                when 'PUT'         then connection.connection.http_put serializer.dump(body)
-                when 'DELETE'      then connection.connection.http_delete
-                when 'POST'
-                  connection.connection.post_body = __convert_to_json(body) if body
-                  connection.connection.http_post
+                when 'HEAD'
+                when 'GET', 'POST', 'PUT', 'DELETE'
+                  connection.connection.put_data = __convert_to_json(body) if body
                 else raise ArgumentError, "Unsupported HTTP method: #{method}"
               end
 
+              connection.connection.http(method.to_sym)
+
               Response.new connection.connection.response_code, connection.connection.body_str
             end
           end
@@ -40,13 +39,19 @@ module Elasticsearch
           def __build_connections
             Connections::Collection.new \
               :connections => hosts.map { |host|
-                host[:protocol] ||= DEFAULT_PROTOCOL
+                host[:protocol]   = host[:scheme] || DEFAULT_PROTOCOL
                 host[:port]     ||= DEFAULT_PORT
 
                 client = ::Curl::Easy.new
                 client.resolve_mode = :ipv4
-                client.headers      = {'Content-Type' => 'application/json'}
-                client.url          = "#{host[:protocol]}://#{host[:host]}:#{host[:port]}"
+                client.headers      = {'User-Agent' => "Curb #{Curl::CURB_VERSION}", 'Content-Type' => 'application/json' }
+                client.url          = __full_url(host)
+
+                if host[:user]
+                  client.http_auth_types = host[:auth_type] || :basic
+                  client.username = host[:user]
+                  client.password = host[:password]
+                end
 
                 client.instance_eval &@block if @block
 

data/lib/elasticsearch/transport/transport/http/faraday.rb

@@ -33,9 +33,9 @@ module Elasticsearch
           def __build_connections
             Connections::Collection.new \
               :connections => hosts.map { |host|
-                host[:protocol] ||= DEFAULT_PROTOCOL
+                host[:protocol]   = host[:scheme] || DEFAULT_PROTOCOL
                 host[:port]     ||= DEFAULT_PORT
-                url               = "#{host[:protocol]}://#{host[:host]}:#{host[:port]}"
+                url               = __full_url(host)
 
                 Connections::Connection.new \
                   :host => host,

data/lib/elasticsearch/transport/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Transport
-    VERSION = "0.4.0"
+    VERSION = "0.4.2"
   end
 end

data/test/integration/client_test.rb

@@ -2,12 +2,13 @@ require 'test_helper'
 
 class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::IntegrationTestCase
   startup do
-    Elasticsearch::TestCluster.start if ENV['SERVER'] and not Elasticsearch::TestCluster.running?
+    Elasticsearch::Extensions::Test::Cluster.start if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running?
   end
 
   context "Elasticsearch client" do
     setup do
-      system "curl -X DELETE http://localhost:9250/_all > /dev/null 2>&1"
+      @port = (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
+      system "curl -X DELETE http://localhost:#{@port}/_all > /dev/null 2>&1"
 
       @logger =  Logger.new(STDERR)
       @logger.formatter = proc do |severity, datetime, progname, msg|
@@ -20,7 +21,7 @@ class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::Int
         ANSI.ansi(severity[0] + ' ', color, :faint) + ANSI.ansi(msg, :white, :faint) + "\n"
       end
 
-      @client = Elasticsearch::Client.new host: 'localhost:9250'
+      @client = Elasticsearch::Client.new host: "localhost:#{@port}"
     end
 
     should "connect to the cluster" do
@@ -32,6 +33,8 @@ class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::Int
 
     should "handle paths and URL parameters" do
       @client.perform_request 'PUT', 'myindex/mydoc/1', {routing: 'XYZ'}, {foo: 'bar'}
+      @client.perform_request 'GET', '_cluster/health?wait_for_status=green', {}
+
       response = @client.perform_request 'GET', 'myindex/mydoc/1?routing=XYZ'
       assert_equal true, response.body['exists']
       assert_equal 'bar', response.body['_source']['foo']
@@ -45,7 +48,7 @@ class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::Int
     context "with round robin selector" do
       setup do
         @client = Elasticsearch::Client.new \
-                    hosts: %w| localhost:9250 localhost:9251 |,
+                    hosts:  ["localhost:#{@port}", "localhost:#{@port+1}" ],
                     logger: @logger
       end
 
@@ -66,8 +69,9 @@ class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::Int
 
     context "with a sick node and retry on failure" do
       setup do
+        @port = (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
         @client = Elasticsearch::Client.new \
-                    hosts: %w| localhost:9250 foobar1 |,
+                    hosts: ["localhost:#{@port}", "foobar1"],
                     logger: @logger,
                     retry_on_failure: true
       end
@@ -80,7 +84,7 @@ class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::Int
 
       should "raise exception when it cannot get any healthy server" do
         @client = Elasticsearch::Client.new \
-                  hosts: %w| localhost:9250 foobar1 foobar2 foobar3 |,
+                  hosts: ["localhost:#{@port}", "foobar1", "foobar2", "foobar3"],
                   logger: @logger,
                   retry_on_failure: 1
 
@@ -99,7 +103,7 @@ class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::Int
     context "with a sick node and reloading on failure" do
       setup do
         @client = Elasticsearch::Client.new \
-                  hosts: %w| localhost:9250 foobar1 foobar2 |,
+                  hosts: ["localhost:#{@port}", "foobar1", "foobar2"],
                   logger: @logger,
                   reload_on_failure: true
       end

data/test/integration/transport_test.rb

@@ -2,16 +2,20 @@ require 'test_helper'
 
 class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::IntegrationTestCase
   startup do
-    Elasticsearch::TestCluster.start if ENV['SERVER'] and not Elasticsearch::TestCluster.running?
+    Elasticsearch::Extensions::Test::Cluster.start if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running?
   end
 
   context "Transport" do
+    setup do
+      @port = (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
+    end
+
     should "allow to customize the Faraday adapter" do
       require 'typhoeus'
       require 'typhoeus/adapters/faraday'
 
       transport = Elasticsearch::Transport::Transport::HTTP::Faraday.new \
-        :hosts => [ { :host => 'localhost', :port => '9250' } ] do |f|
+        :hosts => [ { :host => 'localhost', :port => @port } ] do |f|
           f.response :logger
           f.adapter  :typhoeus
         end
@@ -25,7 +29,7 @@ class Elasticsearch::Transport::ClientIntegrationTest < Elasticsearch::Test::Int
       require 'elasticsearch/transport/transport/http/curb'
 
       transport = Elasticsearch::Transport::Transport::HTTP::Curb.new \
-        :hosts => [ { :host => 'localhost', :port => '9250' } ] do |curl|
+        :hosts => [ { :host => 'localhost', :port => @port } ] do |curl|
           curl.verbose = true
         end
 

data/test/profile/client_benchmark_test.rb

@@ -2,26 +2,27 @@ require 'test_helper'
 
 class Elasticsearch::Transport::ClientProfilingTest < Elasticsearch::Test::ProfilingTest
   startup do
-    Elasticsearch::TestCluster.start if ENV['SERVER'] and not Elasticsearch::TestCluster.running?
+    Elasticsearch::Extensions::Test::Cluster.start if ENV['SERVER'] and not Elasticsearch::Extensions::Test::Cluster.running?
   end
 
   context "Elasticsearch client benchmark" do
     setup do
-      client = Elasticsearch::Client.new host: 'localhost:9250'
+      @port = (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
+      client = Elasticsearch::Client.new host: "localhost:#{@port}"
       client.perform_request 'DELETE', '/ruby_test_benchmark/' rescue nil
       client.perform_request 'POST',   '/ruby_test_benchmark/', {index: {number_of_shards: 1, number_of_replicas: 0}}
       100.times do client.perform_request 'POST',   '/ruby_test_benchmark_search/test/', {}, {foo: 'bar'}; end
       client.perform_request 'POST',   '/ruby_test_benchmark_search/_refresh'
     end
     teardown do
-      client = Elasticsearch::Client.new host: 'localhost:9250'
+      client = Elasticsearch::Client.new host: "localhost:#{@port}"
       client.perform_request 'DELETE', '/ruby_test_benchmark/'
       client.perform_request 'DELETE', '/ruby_test_benchmark_search/'
     end
 
     context "with a single-node cluster" do
       setup do
-        @client = Elasticsearch::Client.new hosts: 'localhost:9250'
+        @client = Elasticsearch::Client.new hosts: "localhost:#{@port}"
       end
 
       measure "get the cluster info", count: 1_000 do
@@ -39,7 +40,7 @@ class Elasticsearch::Transport::ClientProfilingTest < Elasticsearch::Test::Profi
 
     context "with a two-node cluster" do
       setup do
-        @client = Elasticsearch::Client.new hosts: ['localhost:9250', 'localhost:9251']
+        @client = Elasticsearch::Client.new hosts: ["localhost:#{@port}", "localhost:#{@port+1}"]
       end
 
       measure "get the cluster info", count: 1_000 do
@@ -59,7 +60,7 @@ class Elasticsearch::Transport::ClientProfilingTest < Elasticsearch::Test::Profi
       setup do
         require 'curb'
         require 'elasticsearch/transport/transport/http/curb'
-        @client = Elasticsearch::Client.new host: 'localhost:9250',
+        @client = Elasticsearch::Client.new host: "localhost:#{@port}",
                                             transport_class: Elasticsearch::Transport::Transport::HTTP::Curb
       end
 
@@ -82,7 +83,7 @@ class Elasticsearch::Transport::ClientProfilingTest < Elasticsearch::Test::Profi
         require 'typhoeus/adapters/faraday'
 
         transport = Elasticsearch::Transport::Transport::HTTP::Faraday.new \
-          :hosts => [ { :host => 'localhost', :port => '9250' } ] do |f|
+          :hosts => [ { :host => 'localhost', :port => @port } ] do |f|
             f.adapter  :typhoeus
           end
 

data/test/test_helper.rb

@@ -1,6 +1,6 @@
 RUBY_1_8 = defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
 
-if RUBY_1_8
+if RUBY_1_8 and not ENV['BUNDLE_GEMFILE']
   require 'rubygems'
   gem 'test-unit'
 end
@@ -19,15 +19,16 @@ require 'mocha/setup'
 require 'ansi/code'
 require 'turn' unless ENV["TM_FILEPATH"] || ENV["NOTURN"] || RUBY_1_8
 
-require 'test_extensions'
-
 require 'require-prof' if ENV["REQUIRE_PROF"]
 require 'elasticsearch-transport'
-require 'elasticsearch/transport/extensions/test_cluster'
 require 'logger'
 
 RequireProf.print_timing_infos if ENV["REQUIRE_PROF"]
 
+require 'elasticsearch/extensions/test/cluster'
+require 'elasticsearch/extensions/test/startup_shutdown'
+require 'elasticsearch/extensions/test/profiling'
+
 class Test::Unit::TestCase
   def setup
   end
@@ -39,19 +40,19 @@ end
 module Elasticsearch
   module Test
     class IntegrationTestCase < ::Test::Unit::TestCase
-      extend IntegrationTestStartupShutdown
+      extend Elasticsearch::Extensions::Test::StartupShutdown
 
-      shutdown { Elasticsearch::TestCluster.stop if ENV['SERVER'] && started? }
+      shutdown { Elasticsearch::Extensions::Test::Cluster.stop if ENV['SERVER'] && started? }
       context "IntegrationTest" do; should "noop on Ruby 1.8" do; end; end if RUBY_1_8
     end
   end
 
   module Test
     class ProfilingTest < ::Test::Unit::TestCase
-      extend IntegrationTestStartupShutdown
-      extend ProfilingTestSupport
+      extend Elasticsearch::Extensions::Test::StartupShutdown
+      extend Elasticsearch::Extensions::Test::Profiling
 
-      shutdown { Elasticsearch::TestCluster.stop if ENV['SERVER'] && started? }
+      shutdown { Elasticsearch::Extensions::Test::Cluster.stop if ENV['SERVER'] && started? }
       context "IntegrationTest" do; should "noop on Ruby 1.8" do; end; end if RUBY_1_8
     end
   end

data/test/unit/client_test.rb

@@ -66,30 +66,83 @@ class Elasticsearch::Transport::ClientTest < Test::Unit::TestCase
 
     context "extracting hosts" do
       should "handle defaults" do
-        assert_equal [ {:host => 'localhost', :port => nil} ], @client.__extract_hosts
+        hosts = @client.__extract_hosts
+
+        assert_equal 'localhost', hosts[0][:host]
+        assert_nil                hosts[0][:port]
       end
 
       should "extract from string" do
-        assert_equal [ {:host => 'myhost', :port => nil} ], @client.__extract_hosts( 'myhost' )
+        hosts = @client.__extract_hosts 'myhost'
+
+        assert_equal 'myhost', hosts[0][:host]
+        assert_nil             hosts[0][:port]
       end
 
       should "extract from array" do
-        assert_equal [ {:host => 'myhost', :port => nil} ], @client.__extract_hosts( ['myhost'] )
+        hosts = @client.__extract_hosts ['myhost']
+
+        assert_equal 'myhost', hosts[0][:host]
       end
 
       should "extract from array with multiple hosts" do
-        assert_equal [ {:host => 'host1', :port => nil}, {:host => 'host2', :port => nil} ],
-                     @client.__extract_hosts( ['host1', 'host2'] )
+        hosts = @client.__extract_hosts ['host1', 'host2']
+
+        assert_equal 'host1', hosts[0][:host]
+        assert_equal 'host2', hosts[1][:host]
       end
 
       should "extract from array with ports" do
-        assert_equal [ {:host => 'host1', :port => '1000'}, {:host => 'host2', :port => '2000'} ],
-                     @client.__extract_hosts( ['host1:1000', 'host2:2000'] )
+        hosts = @client.__extract_hosts ['host1:1000', 'host2:2000']
+
+        assert_equal 'host1', hosts[0][:host]
+        assert_equal '1000',  hosts[0][:port]
+
+        assert_equal 'host2', hosts[1][:host]
+        assert_equal '2000',  hosts[1][:port]
+      end
+
+      should "extract path" do
+        hosts = @client.__extract_hosts 'https://myhost:8080/api'
+
+        assert_equal '/api',  hosts[0][:path]
+      end
+
+      should "extract scheme (protocol)" do
+        hosts = @client.__extract_hosts 'https://myhost:8080'
+
+        assert_equal 'https',  hosts[0][:scheme]
+        assert_equal 'myhost', hosts[0][:host]
+        assert_equal '8080',   hosts[0][:port]
+      end
+
+      should "extract credentials" do
+        hosts = @client.__extract_hosts 'http://USERNAME:PASSWORD@myhost:8080'
+
+        assert_equal 'http',     hosts[0][:scheme]
+        assert_equal 'USERNAME', hosts[0][:user]
+        assert_equal 'PASSWORD', hosts[0][:password]
+        assert_equal 'myhost',   hosts[0][:host]
+        assert_equal '8080',     hosts[0][:port]
       end
 
       should "pass Hashes over" do
-        assert_equal [ {:host => 'myhost', :port => '1000'} ],
-                     @client.__extract_hosts( [{:host => 'myhost', :port => '1000'}] )
+        hosts = @client.__extract_hosts [{:host => 'myhost', :port => '1000', :foo => 'bar'}]
+
+        assert_equal 'myhost', hosts[0][:host]
+        assert_equal '1000',   hosts[0][:port]
+        assert_equal 'bar',    hosts[0][:foo]
+      end
+
+      should "use URL instance" do
+        require 'uri'
+        hosts = @client.__extract_hosts URI.parse('https://USERNAME:PASSWORD@myhost:4430')
+
+        assert_equal 'https',    hosts[0][:scheme]
+        assert_equal 'USERNAME', hosts[0][:user]
+        assert_equal 'PASSWORD', hosts[0][:password]
+        assert_equal 'myhost',   hosts[0][:host]
+        assert_equal '4430',     hosts[0][:port]
       end
 
       should "raise error for incompatible argument" do
@@ -100,7 +153,10 @@ class Elasticsearch::Transport::ClientTest < Test::Unit::TestCase
 
       should "randomize hosts" do
         hosts = [ {:host => 'host1'}, {:host => 'host2'}, {:host => 'host3'}, {:host => 'host4'}, {:host => 'host5'}]
-        assert_not_equal     hosts, @client.__extract_hosts(hosts, :randomize_hosts => true)
+
+        Array.any_instance.expects(:shuffle!).twice
+
+        @client.__extract_hosts(hosts, :randomize_hosts => true)
         assert_same_elements hosts, @client.__extract_hosts(hosts, :randomize_hosts => true)
       end
     end

data/test/unit/connection_test.rb

@@ -25,6 +25,16 @@ class Elasticsearch::Transport::Transport::Connections::ConnectionTest < Test::U
       assert_equal 'http://localhost:9200/_search?foo=bar', c.full_url('_search', {:foo => 'bar'})
     end
 
+    should "return full url with credentials" do
+      c = Connection.new :host => { :protocol => 'http', :user => 'U', :password => 'P', :host => 'localhost', :port => '9200' }
+      assert_equal 'http://U:P@localhost:9200/_search?foo=bar', c.full_url('_search', {:foo => 'bar'})
+    end
+
+    should "return full url with path" do
+      c = Connection.new :host => { :protocol => 'http', :host => 'localhost', :port => '9200', :path => '/foo' }
+      assert_equal 'http://localhost:9200/foo/_search?foo=bar', c.full_url('_search', {:foo => 'bar'})
+    end
+
     should "have a string representation" do
       c = Connection.new :host => 'x'
       assert_match /host: x/, c.to_s

data/test/unit/sniffer_test.rb

@@ -135,10 +135,9 @@ class Elasticsearch::Transport::Transport::SnifferTest < Test::Unit::TestCase
         }
       JSON
 
-      hosts = @sniffer.hosts
+      Array.any_instance.expects(:shuffle!)
 
-      assert_not_equal       ['Node 1', 'Node 2', 'Node 3', 'Node 4', 'Node 5'], hosts.map { |h| h['name'] }
-      assert_same_elements ['Node 1', 'Node 2', 'Node 3', 'Node 4', 'Node 5'], hosts.map { |h| h['name'] }
+      hosts = @sniffer.hosts
     end
 
   end

data/test/unit/transport_base_test.rb

@@ -57,6 +57,25 @@ class Elasticsearch::Transport::Transport::BaseTest < Test::Unit::TestCase
       transport = DummyTransport.new :options => { :sniffer_class => DummySniffer }
       assert_instance_of DummySniffer, transport.sniffer
     end
+
+    context "when combining the URL" do
+      setup do
+        @transport   = DummyTransport.new
+        @basic_parts = { :protocol => 'http', :host => 'myhost', :port => 8080 }
+      end
+
+      should "combine basic parts" do
+        assert_equal 'http://myhost:8080', @transport.__full_url(@basic_parts)
+      end
+
+      should "combine path" do
+        assert_equal 'http://myhost:8080/api', @transport.__full_url(@basic_parts.merge :path => '/api')
+      end
+
+      should "combine authentication credentials" do
+        assert_equal 'http://U:P@myhost:8080', @transport.__full_url(@basic_parts.merge :user => 'U', :password => 'P')
+      end
+    end
   end
 
   context "getting a connection" do
@@ -260,7 +279,9 @@ class Elasticsearch::Transport::Transport::BaseTest < Test::Unit::TestCase
     end
 
     should "log the request and response" do
-      @transport.logger.expects(:info).  with "POST localhost:9200/_search?size=1 [status:200, request:0.000s, query:n/a]"
+      @transport.logger.expects(:info).  with do |line|
+        line =~ %r|POST localhost\:9200/_search\?size=1 \[status\:200, request:.*s, query:n/a\]|
+      end
       @transport.logger.expects(:debug). with '> {"foo":"bar"}'
       @transport.logger.expects(:debug). with '< {"foo":"bar"}'
 

data/test/unit/transport_curb_test.rb

@@ -14,7 +14,7 @@ class Elasticsearch::Transport::Transport::HTTP::FaradayTest < Test::Unit::TestC
       assert_equal 1, @transport.hosts.size
       assert_equal 1, @transport.connections.size
 
-      assert_instance_of ::Curl::Easy, @transport.connections.first.connection
+      assert_instance_of ::Curl::Easy,   @transport.connections.first.connection
       assert_equal 'http://foobar:1234', @transport.connections.first.connection.url
     end
 
@@ -23,23 +23,36 @@ class Elasticsearch::Transport::Transport::HTTP::FaradayTest < Test::Unit::TestC
       @transport.perform_request 'GET', '/'
     end
 
+    should "set body for GET request" do
+      @transport.connections.first.connection.expects(:put_data=).with('{"foo":"bar"}')
+      @transport.connections.first.connection.expects(:http).with(:GET).returns(stub_everything)
+      @transport.perform_request 'GET', '/', {}, '{"foo":"bar"}'
+    end
+
+    should "set body for PUT request" do
+      @transport.connections.first.connection.expects(:put_data=)
+      @transport.connections.first.connection.expects(:http).with(:PUT).returns(stub_everything)
+      @transport.perform_request 'PUT', '/', {}, {:foo => 'bar'}
+    end
+
     should "serialize the request body" do
-      @transport.connections.first.connection.expects(:http_post).returns(stub_everything)
+      @transport.connections.first.connection.expects(:http).with(:POST).returns(stub_everything)
       @transport.serializer.expects(:dump)
       @transport.perform_request 'POST', '/', {}, {:foo => 'bar'}
     end
 
     should "not serialize a String request body" do
-      @transport.connections.first.connection.expects(:http_post).returns(stub_everything)
+      @transport.connections.first.connection.expects(:http).with(:POST).returns(stub_everything)
       @transport.serializer.expects(:dump).never
       @transport.perform_request 'POST', '/', {}, '{"foo":"bar"}'
     end
 
     should "handle HTTP methods" do
-      @transport.connections.first.connection.expects(:http).twice.returns(stub_everything)
-      @transport.connections.first.connection.expects(:http_put).returns(stub_everything)
-      @transport.connections.first.connection.expects(:http_post).returns(stub_everything)
-      @transport.connections.first.connection.expects(:http_delete).returns(stub_everything)
+      @transport.connections.first.connection.expects(:http).with(:HEAD).returns(stub_everything)
+      @transport.connections.first.connection.expects(:http).with(:GET).returns(stub_everything)
+      @transport.connections.first.connection.expects(:http).with(:PUT).returns(stub_everything)
+      @transport.connections.first.connection.expects(:http).with(:POST).returns(stub_everything)
+      @transport.connections.first.connection.expects(:http).with(:DELETE).returns(stub_everything)
 
       %w| HEAD GET PUT POST DELETE |.each { |method| @transport.perform_request method, '/' }
 
@@ -54,6 +67,12 @@ class Elasticsearch::Transport::Transport::HTTP::FaradayTest < Test::Unit::TestC
       assert_equal( {"Content-Type"=>"application/json", "User-Agent"=>"myapp-0.0"},
                     transport.connections.first.connection.headers )
     end
+
+    should "set the credentials if passed" do
+      transport = Curb.new :hosts => [ { :host => 'foobar', :port => 1234, :user => 'foo', :password => 'bar' } ]
+      assert_equal 'foo', transport.connections.first.connection.username
+      assert_equal 'bar', transport.connections.first.connection.password
+    end
   end
 
 end

data/test/unit/transport_faraday_test.rb

@@ -17,7 +17,7 @@ class Elasticsearch::Transport::Transport::HTTP::FaradayTest < Test::Unit::TestC
       assert_equal 1, @transport.connections.size
 
       assert_instance_of ::Faraday::Connection, @transport.connections.first.connection
-      assert_equal 'http://foobar:1234/', @transport.connections.first.connection.url_prefix.to_s
+      assert_equal 'http://foobar:1234/',       @transport.connections.first.connection.url_prefix.to_s
     end
 
     should "perform the request" do
@@ -68,6 +68,11 @@ class Elasticsearch::Transport::Transport::HTTP::FaradayTest < Test::Unit::TestC
       handlers = transport.connections.first.connection.instance_variable_get(:@builder).instance_variable_get(:@handlers)
       assert handlers.include?(::Faraday::Response::Logger), "#{handlers.inspect} does not include <::Faraday::Adapter::Typhoeus>"
     end
+
+    should "set the credentials if passed" do
+      transport = Faraday.new :hosts => [ { :host => 'foobar', :port => 1234, :user => 'foo', :password => 'bar' } ]
+      assert_equal 'Basic Zm9vOmJhcg==', transport.connections.first.connection.headers['Authorization']
+    end
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-transport
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-24 00:00:00.000000000 Z
+date: 2013-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -75,6 +75,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: elasticsearch-extensions
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ansi
   requirement: !ruby/object:Gem::Requirement
@@ -172,7 +188,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: curb
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -188,7 +204,23 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: typhoeus
+  name: ci_reporter
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: curb
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -203,6 +235,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -251,6 +299,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ! 'Ruby client for Elasticsearch. See the `elasticsearch` gem for full
   integration.
 
@@ -272,7 +336,6 @@ files:
 - lib/elasticsearch-transport.rb
 - lib/elasticsearch/transport.rb
 - lib/elasticsearch/transport/client.rb
-- lib/elasticsearch/transport/extensions/test_cluster.rb
 - lib/elasticsearch/transport/transport/base.rb
 - lib/elasticsearch/transport/transport/connections/collection.rb
 - lib/elasticsearch/transport/transport/connections/connection.rb
@@ -287,7 +350,6 @@ files:
 - test/integration/client_test.rb
 - test/integration/transport_test.rb
 - test/profile/client_benchmark_test.rb
-- test/test_extensions.rb
 - test/test_helper.rb
 - test/unit/client_test.rb
 - test/unit/connection_collection_test.rb
@@ -328,7 +390,6 @@ test_files:
 - test/integration/client_test.rb
 - test/integration/transport_test.rb
 - test/profile/client_benchmark_test.rb
-- test/test_extensions.rb
 - test/test_helper.rb
 - test/unit/client_test.rb
 - test/unit/connection_collection_test.rb

data/lib/elasticsearch/transport/extensions/test_cluster.rb

@@ -1,163 +0,0 @@
-require 'ansi/code'
-
-module Elasticsearch
-
-  # A convenience Ruby class for starting and stopping a separate testing cluster,
-  # to not depend on -- and not mess up -- <localhost:9200>.
-  #
-  module TestCluster
-    require 'timeout'
-    require 'net/http'
-    require 'uri'
-
-    @@number_of_nodes = 2
-    @@pids            = []
-
-    # Start a cluster
-    #
-    # Starts the desired number of nodes in test-suitable configuration (memory store, no persistence, etc).
-    #
-    # @option arguments [String]  :command      Elasticsearch command (default: `elasticsearch`).
-    # @option arguments [Integer] :count        Number of desired nodes (default: 2).
-    # @option arguments [String]  :cluster_name Cluster name (default: `elasticsearch-ruby-test`).
-    # @option arguments [String]  :port         Starting port number; will be auto-incremented (default: 9250).
-    #
-    # You can also use environment variables to set these options.
-    #
-    def start(arguments={})
-      arguments[:command] = ENV['TEST_CLUSTER_COMMAND'] || 'elasticsearch'
-
-      unless system "which #{arguments[:command]} > /dev/null 2>&1"
-        STDERR.puts ANSI.red("[ERROR] Elasticsearch can't be started, is it installed? Run: $ which elasticsearch"), ''
-        abort
-      end
-
-      @@number_of_nodes = arguments[:count] if arguments[:count]
-
-      arguments[:port]         = (ENV['TEST_CLUSTER_PORT'] || 9250).to_i
-      arguments[:cluster_name] = ENV['TEST_CLUSTER_NAME'] || 'elasticsearch-ruby-test'
-      arguments[:node_name]    = 'node'
-
-      if running? :on => arguments[:port], :as => arguments[:cluster_name]
-        print ANSI.red("Elasticsearch cluster already running")
-        __wait_for_green(arguments[:port])
-        exit(0)
-      end
-
-      print ANSI.faint("Starting ") + ANSI.ansi(@@number_of_nodes.to_s, :bold, :faint) + ANSI.faint(" Elasticsearch nodes")
-
-      @@number_of_nodes.times do |n|
-        n += 1
-        pidfile = File.expand_path("tmp/elasticsearch-#{n}.pid", Dir.pwd)
-        pid = Process.spawn <<-COMMAND
-          #{arguments[:command]} \
-            -D es.foreground=yes \
-            -D es.cluster.name=#{arguments[:cluster_name]} \
-            -D es.node.name=#{arguments[:node_name]}-#{n} \
-            -D es.http.port=#{arguments[:port].to_i + (n-1)} \
-            -D es.gateway.type=none \
-            -D es.index.store.type=memory \
-            -D es.network.host=0.0.0.0 \
-            -D es.discovery.zen.ping.multicast.enabled=true \
-            -D es.pidfile=#{pidfile} \
-            > /dev/null 2>&1
-        COMMAND
-        Process.detach pid
-      end
-
-      __wait_for_green(arguments[:port])
-    end
-
-    # Stop the cluster.
-    #
-    # Gets the PID numbers from pidfiles in `$CWD/tmp` and stops any matching nodes.
-    #
-    def stop
-      pids     = __get_pids
-      pidfiles = __get_pidfiles
-
-      unless pids.empty?
-        print "Stopping Elasticsearch nodes... "
-        pids.each_with_index do |pid, i|
-          begin
-            print ANSI.green("stopped PID #{pid}. ") if Process.kill 'KILL', pid
-          rescue Exception => e
-            print ANSI.red("[#{e.class}] PID #{pid} not found. ")
-          end
-          File.delete pidfiles[i] if pidfiles[i] && File.exists?(pidfiles[i])
-        end
-        puts
-      end
-    end
-
-    # Returns true when a specific test node is running.
-    #
-    # @option arguments [Integer] :on The port on which the node is running.
-    # @option arguments [String]  :as The cluster name.
-    #
-    def running?(arguments={})
-      port         = arguments[:on] || 9250
-      cluster_name = arguments[:as] || 'elasticsearch-ruby-test'
-
-      if cluster_health = Timeout::timeout(0.25) { __get_cluster_health(port) } rescue nil
-        return cluster_health['cluster_name']    == cluster_name && \
-               cluster_health['number_of_nodes'] == @@number_of_nodes
-      end
-      return false
-    end
-
-    # Blocks the process and waits for the cluster to be in a "green" state.
-    # Prints information about the cluster on STDOUT.
-    #
-    def __wait_for_green(port=9250)
-      uri = URI("http://localhost:#{port}/_cluster/health")
-
-      Timeout::timeout(30) do
-        loop do
-          response = Net::HTTP.get(uri) rescue nil
-          if response
-            pids = __get_pids
-
-            json = MultiJson.load(response)
-            if json['status'] == 'green' && json['number_of_nodes'].to_i == @@number_of_nodes
-              puts '',
-                   ANSI.faint('-'*80),
-                   ANSI.faint(
-                    'Cluster: '.ljust(20)         + json['cluster_name'].to_s    + "\n" +
-                    'Status: '.ljust(20)          + json['status'].to_s          + "\n" +
-                    'Number of nodes: '.ljust(20) + json['number_of_nodes'].to_s + "\n" +
-                    'PIDs'.ljust(20)              + pids.inspect
-                  ),
-                  ANSI.faint('-'*80)
-              break
-            end
-          end
-          print ANSI.faint('.')
-          sleep 1
-        end
-      end
-    end
-
-    # Tries to load cluster health information
-    #
-    def __get_cluster_health(port=9250)
-      uri = URI("http://localhost:#{port}/_cluster/health")
-      if response = Net::HTTP.get(uri) rescue nil
-        return MultiJson.load(response)
-      end
-    end
-
-    # Returns a collection of PID numbers from pidfiles.
-    def __get_pids
-      __get_pidfiles.map { |pidfile| File.read(pidfile).to_i }.uniq
-    end
-
-    # Returns a collection of files with PID information.
-    #
-    def __get_pidfiles
-      Dir[File.expand_path('tmp/elasticsearch-*.pid', Dir.pwd)]
-    end
-
-    extend self
-  end
-end

data/test/test_extensions.rb

@@ -1,139 +0,0 @@
-require 'benchmark'
-require 'ruby-prof'
-require 'ansi/code'
-require 'ansi/terminal'
-
-module Elasticsearch
-  module Test
-
-    # Startup/shutdown support for test suites
-    #
-    # Example:
-    #
-    #     class MyTest < Test::Unit::TestCase
-    #       extend IntegrationTestStartupShutdown
-    #
-    #       startup  { puts "Suite starting up..." }
-    #       shutdown { puts "Suite shutting down..." }
-    #     end
-    #
-    # *** IMPORTANT NOTE: **********************************************************
-    #
-    # You have to register the handler for shutdown before requiring 'test/unit':
-    #
-    #     # File: test_helper.rb
-    #     at_exit { MyTest.__run_at_exit_hooks }
-    #     require 'test/unit'
-    #
-    # The API follows Test::Unit 2.0
-    # <https://github.com/test-unit/test-unit/blob/master/lib/test/unit/testcase.rb>
-    #
-    module IntegrationTestStartupShutdown
-      @@started           = false
-      @@shutdown_blocks ||= []
-
-      def startup &block
-        return if started?
-        @@started = true
-        yield block if block_given?
-      end
-
-      def shutdown &block
-        @@shutdown_blocks << block if block_given?
-      end
-
-      def started?
-        !! @@started
-      end
-
-      def __run_at_exit_hooks
-        return unless started?
-        STDERR.puts ANSI.faint("Running at_exit hooks...")
-        puts ANSI.faint('-'*80)
-        @@shutdown_blocks.each { |b| b.call }
-        puts ANSI.faint('-'*80)
-      end
-    end
-
-    # Profiling support for tests with [ruby-prof](https://github.com/ruby-prof/ruby-prof)
-    #
-    # Example:
-    #
-    #     measure "divide numbers", count: 10_000 do
-    #      assert_nothing_raised { 1/2 }
-    #     end
-    #
-    # Will print out something like this along your test output:
-    #
-    #     ---------------------------------------------------------------------
-    #     Context: My benchmark should divide numbers (10000x)
-    #     mean: 0.01ms | avg: 0.01ms | max: 6.19ms
-    #     ---------------------------------------------------------------------
-    #     ...
-    #     Total: 0.313283
-    #
-    #      %self      total      self      wait     child     calls  name
-    #      25.38      0.313     0.079     0.000     0.234        1   <Object::MyTets>#__bind_1368638677_723101
-    #      14.42      0.118     0.045     0.000     0.073    20000   <Class::Time>#now
-    #      7.57       0.088     0.033     0.000     0.055    10000   Time#-
-    #      ...
-    #
-    #     PASS (0:00:00.322) test: My benchmark should divide numbers (10000x).
-    #
-    #
-    module ProfilingTestSupport
-
-      # Profiles the passed block of code.
-      #
-      #     measure "divide numbers", count: 10_000 do
-      #      assert_nothing_raised { 1/2 }
-      #     end
-      #
-      # @todo Try to make progress bar not interfere with tests
-      #
-      def measure(name, options={}, &block)
-        # require 'pry'; binding.pry
-        ___          = '-'*ANSI::Terminal.terminal_width
-        test_name    = self.name.split('::').last
-        context_name = self.context(nil) {}.first.parent.name
-        count        = Integer(ENV['COUNT'] || options[:count] || 1_000)
-        ticks        = []
-        # progress   = ANSI::Progressbar.new("#{name} (#{count}x)", count)
-
-        should "#{name} (#{count}x)" do
-          RubyProf.start
-
-          count.times do
-            ticks << Benchmark.realtime { self.instance_eval(&block) }
-            # RubyProf.pause
-            # progress.inc
-            # RubyProf.resume
-          end
-
-          result = RubyProf.stop
-          # progress.finish
-
-          total = result.threads.reduce(0) { |total,info| total += info.total_time; total }
-          mean  = (ticks.sort[(ticks.size/2).round-1])*1000
-          avg   = (ticks.inject {|sum,el| sum += el; sum}.to_f/ticks.size)*1000
-          max   = ticks.max*1000
-
-
-          result.eliminate_methods!([/Integer#times|Benchmark.realtime|ANSI::Code#.*|ANSI::ProgressBar#.*/])
-          printer = RubyProf::FlatPrinter.new(result)
-          # printer = RubyProf::GraphPrinter.new(result)
-
-          puts "\n",
-               ___,
-               'Context: ' + ANSI.bold(context_name) + ' should ' + ANSI.bold(name) + " (#{count}x)",
-               "mean: #{sprintf('%.2f', mean)}ms | " +
-               "avg: #{sprintf('%.2f',  avg)}ms | " +
-               "max: #{sprintf('%.2f',  max)}ms",
-               ___
-          printer.print(STDOUT, {}) unless ENV['QUIET'] || options[:quiet]
-        end
-      end
-    end
-
-  end
-end