logstash-output-elasticsearch 5.4.1-java → 6.0.0-java

data/spec/unit/outputs/elasticsearch_proxy_spec.rb

@@ -4,12 +4,7 @@ require "logstash/outputs/elasticsearch"
 require 'manticore/client'
 
 describe "Proxy option" do
-  let(:settings) {
-    {
-      "hosts" => "node01",
-      "proxy" => proxy
-    }
-  }
+  let(:settings) { { "hosts" => "node01" } }
   subject {
     LogStash::Outputs::ElasticSearch.new(settings)
   }
@@ -23,30 +18,46 @@ describe "Proxy option" do
       subject.register
     end
 
-    context "when specified as a string" do
-      let(:proxy) { "http://127.0.0.1:1234" }
-
-      it "should set the proxy to the exact value" do
-        expect(::Manticore::Client).to have_received(:new) do |options|
-          expect(options[:proxy]).to eql(proxy)
+    context "when specified as a URI" do
+      shared_examples("hash conversion") do |hash|
+        let(:settings) { super.merge("proxy" => proxy)}
+        
+        it "should set the proxy to the correct hash value" do
+          expect(::Manticore::Client).to have_received(:new) do |options|
+            expect(options[:proxy]).to eq(hash)
+          end
         end
       end
-    end
+      
+      describe "simple proxy" do
+        let(:proxy) { LogStash::Util::SafeURI.new("http://127.0.0.1:1234") }
 
-    context "when specified as a hash" do
-      let(:proxy) { {"hosts" => "127.0.0.1", "protocol" => "http"} }
+        include_examples("hash conversion",
+          {
+            :host => "127.0.0.1",
+            :scheme => "http",
+            :port => 1234  
+          }
+        )
+      end
+      
+      
+      describe "a secure authed proxy" do
+        let(:proxy) { LogStash::Util::SafeURI.new("https://myuser:mypass@127.0.0.1:1234") }
 
-      it "should pass through the proxy values as symbols" do
-        expected = {:hosts => proxy["hosts"], :protocol => proxy["protocol"]}
-        expect(::Manticore::Client).to have_received(:new) do |options|
-          expect(options[:proxy]).to eql(expected)
-        end
+        include_examples("hash conversion",
+          {
+            :host => "127.0.0.1",
+            :scheme => "https",
+            :user => "myuser",
+            :password => "mypass",
+            :port => 1234  
+          }
+        )
       end
     end
 
     context "when not specified" do
-      let(:proxy) { nil }
-      
       it "should not send the proxy option to manticore" do
         expect(::Manticore::Client).to have_received(:new) do |options|
           expect(options).not_to include(:proxy)
@@ -54,15 +65,4 @@ describe "Proxy option" do
       end
     end
   end
-
-  describe "invalid configs" do
-    let(:proxy) { ["bad", "stuff"] }
-
-    it "should have raised an exception" do
-      expect {
-        subject.register
-      }.to raise_error(LogStash::ConfigurationError)
-    end
-  end
-
 end

data/spec/unit/outputs/elasticsearch_spec.rb

@@ -8,23 +8,34 @@ describe "outputs/elasticsearch" do
       {
         "index" => "my-index",
         "hosts" => ["localhost","localhost:9202"],
-        "path" => "some-path"
+        "path" => "some-path",
+        "manage_template" => false
       }
     }
-
-    let(:eso) {LogStash::Outputs::ElasticSearch.new(options)}
+    
+    let(:eso) { LogStash::Outputs::ElasticSearch.new(options) }
 
     let(:manticore_urls) { eso.client.pool.urls }
     let(:manticore_url) { manticore_urls.first }
 
     let(:do_register) { true }
 
-    around(:each) do |block|
-      eso.register if do_register
-      block.call()
-      eso.close if do_register
+    before(:each) do
+      if do_register
+        eso.register
+        
+        # Rspec mocks can't handle background threads, so... we can't use any 
+        allow(eso.client.pool).to receive(:start_resurrectionist)
+        allow(eso.client.pool).to receive(:start_sniffer)
+        allow(eso.client.pool).to receive(:healthcheck!)
+        eso.client.pool.adapter.manticore.respond_with(:body => "{}")
+      end
     end
-
+    
+    after(:each) do
+      eso.close 
+    end
+    
     describe "getting a document type" do
       it "should default to 'logs'" do
         expect(eso.send(:get_event_type, LogStash::Event.new)).to eql("logs")
@@ -59,13 +70,43 @@ describe "outputs/elasticsearch" do
         end
       end
     end
+    
+    describe "with auth" do
+      let(:user) { "myuser" }
+      let(:password) { ::LogStash::Util::Password.new("mypassword") }
+      
+      shared_examples "an authenticated config" do
+        it "should set the URL auth correctly" do
+          expect(manticore_url.user).to eq user
+        end
+      end
+        
+      context "as part of a URL" do
+        let(:options) {
+          super.merge("hosts" => ["http://#{user}:#{password.value}@localhost:9200"])
+        }
+        
+        include_examples("an authenticated config")
+      end
+      
+      context "as a hash option" do
+          let(:options) {
+            super.merge!(
+              "user" => user,
+              "password" => password
+            )
+        }
+        
+        include_examples("an authenticated config")
+      end
+    end
 
     describe "with path" do
       it "should properly create a URI with the path" do
         expect(eso.path).to eql(options["path"])
       end
 
-      it "should properly set the path on the HTTP client adding slashes" do
+        it "should properly set the path on the HTTP client adding slashes" do
         expect(manticore_url.path).to eql("/" + options["path"] + "/")
       end
 
@@ -185,6 +226,7 @@ describe "outputs/elasticsearch" do
     end
 
     it "should fail after the timeout" do
+      #pending("This is tricky now that we do healthchecks on instantiation")
       Thread.new { eso.multi_receive([LogStash::Event.new]) }
 
       # Allow the timeout to occur
@@ -214,19 +256,35 @@ describe "outputs/elasticsearch" do
   end
 
   describe "SSL end to end" do
-    shared_examples("an encrypted client connection") do
-      it "should enable SSL in manticore" do
-        expect(eso.client.pool.urls.map(&:scheme).uniq).to eql(['https'])
-      end
+    let(:manticore_double) do 
+      double("manticoreX#{self.inspect}") 
     end
-
+    
     let(:eso) {LogStash::Outputs::ElasticSearch.new(options)}
-    subject(:manticore) { eso.client.pool.adapter.client}
 
-    before do
+    before(:each) do
+      response_double = double("manticore response").as_null_object
+      # Allow healtchecks
+      allow(manticore_double).to receive(:head).with(any_args).and_return(response_double)
+      allow(manticore_double).to receive(:get).with(any_args).and_return(response_double)
+      allow(manticore_double).to receive(:close)
+        
+      allow(::Manticore::Client).to receive(:new).and_return(manticore_double)
       eso.register
     end
+    
+    after(:each) do
+      eso.close
+    end
+    
+    
+    shared_examples("an encrypted client connection") do
+      it "should enable SSL in manticore" do
+        expect(eso.client.pool.urls.map(&:scheme).uniq).to eql(['https'])
+      end
+    end
 
+      
     context "With the 'ssl' option" do
       let(:options) { {"ssl" => true}}
 

data/spec/unit/outputs/elasticsearch_ssl_spec.rb

@@ -3,6 +3,18 @@ require 'stud/temporary'
 require "logstash/outputs/elasticsearch"
 
 describe "SSL option" do
+  let(:manticore_double) { double("manticoreSSL #{self.inspect}") }
+  before do
+    allow(manticore_double).to receive(:close)
+    
+    response_double = double("manticore response").as_null_object
+    # Allow healtchecks
+    allow(manticore_double).to receive(:head).with(any_args).and_return(response_double)
+    allow(manticore_double).to receive(:get).with(any_args).and_return(response_double)
+    
+    allow(::Manticore::Client).to receive(:new).and_return(manticore_double)
+  end
+  
   context "when using ssl without cert verification" do
     subject do
       require "logstash/outputs/elasticsearch"
@@ -13,13 +25,18 @@ describe "SSL option" do
         "pool_max" => 1,
         "pool_max_per_route" => 1
       }
-      next LogStash::Outputs::ElasticSearch.new(settings)
+      LogStash::Outputs::ElasticSearch.new(settings)
     end
-
+    
+    after do
+      subject.close
+    end
+    
     it "should pass the flag to the ES client" do
-      expect(::Manticore::Client).to receive(:new).and_call_original do |args|
+      expect(::Manticore::Client).to receive(:new) do |args|
         expect(args[:ssl]).to eq(:enabled => true, :verify => false)
-      end
+      end.and_return(manticore_double)
+      
       subject.register
     end
 
@@ -27,7 +44,9 @@ describe "SSL option" do
       disabled_matcher = /You have enabled encryption but DISABLED certificate verification/
       expect(subject.logger).to receive(:warn).with(disabled_matcher).at_least(:once)
       allow(subject.logger).to receive(:warn).with(any_args)
+      
       subject.register
+      allow(LogStash::Outputs::ElasticSearch::HttpClient::Pool).to receive(:start)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-elasticsearch
 version: !ruby/object:Gem::Version
-  version: 5.4.1
+  version: 6.0.0
 platform: java
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-12-14 00:00:00.000000000 Z
+date: 2016-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -189,7 +189,6 @@ files:
 - lib/logstash/outputs/elasticsearch/http_client/manticore_adapter.rb
 - lib/logstash/outputs/elasticsearch/http_client/pool.rb
 - lib/logstash/outputs/elasticsearch/http_client_builder.rb
-- lib/logstash/outputs/elasticsearch/safe_url.rb
 - lib/logstash/outputs/elasticsearch/template_manager.rb
 - logstash-output-elasticsearch.gemspec
 - spec/es_spec_helper.rb
@@ -216,7 +215,6 @@ files:
 - spec/unit/outputs/elasticsearch_spec.rb
 - spec/unit/outputs/elasticsearch_ssl_spec.rb
 - spec/unit/outputs/error_whitelist_spec.rb
-- spec/unit/safe_url_spec.rb
 homepage: http://logstash.net/
 licenses:
 - apache-2.0
@@ -268,4 +266,3 @@ test_files:
 - spec/unit/outputs/elasticsearch_spec.rb
 - spec/unit/outputs/elasticsearch_ssl_spec.rb
 - spec/unit/outputs/error_whitelist_spec.rb
-- spec/unit/safe_url_spec.rb

data/lib/logstash/outputs/elasticsearch/safe_url.rb

@@ -1,16 +0,0 @@
-module LogStash; module Outputs; class ElasticSearch;
-  module SafeURL
-    PLACEHOLDER = "~hidden~".freeze
-
-    module_function
-
-    # Takes a URI object and returns a copy of it with any user or password
-    # information replaced with a placeholder `~hidden~`.
-    def without_credentials(url)
-      url.dup.tap do |u|
-        u.user = PLACEHOLDER if u.user
-        u.password = PLACEHOLDER if u.password
-      end
-    end
-  end
-end end end

data/spec/unit/safe_url_spec.rb

@@ -1,46 +0,0 @@
-require "logstash/outputs/elasticsearch/safe_url"
-require "uri"
-
-describe ::LogStash::Outputs::ElasticSearch::SafeURL do
-  let(:placeholder) { ::LogStash::Outputs::ElasticSearch::SafeURL::PLACEHOLDER }
-
-  context "#without_credentials" do
-    subject { described_class.without_credentials(url) }
-
-    shared_examples_for "returning a new object" do
-      it "should return a new url object" do
-        expect(subject.object_id).not_to be == url.object_id
-      end
-    end
-
-    context "when given a url without credentials" do
-      let(:url) { URI.parse("https://example.com/") }
-
-      it_behaves_like "returning a new object"
-
-      it "should return the same url" do
-        expect(subject).to be == url
-      end
-    end
-
-    context "when url contains credentials" do
-      let(:url) { URI.parse("https://user:pass@example.com/") }
-
-      it_behaves_like "returning a new object"
-      
-      it "should hide the user" do
-        expect(subject.user).to be == placeholder
-      end
-
-      it "should hide the password" do
-        expect(subject.user).to be == placeholder
-      end
-
-      context "#to_s" do
-        it "should not contain credentials" do
-          expect(subject.to_s).to be == "https://#{placeholder}:#{placeholder}@example.com/"
-        end
-      end
-    end
-  end
-end