logstash-core 6.8.20-java → 7.0.0.alpha1-java

data/spec/logstash/filters/base_spec.rb

@@ -280,41 +280,6 @@ describe LogStash::Filters::NOOP do
     end
   end
 
-  describe "remove_field within @metadata" do
-    config <<-CONFIG
-    filter {
-      noop {
-        remove_field => ["[@metadata][f1]", "[@metadata][f2]", "[@metadata][f4][f5]"]
-      }
-    }
-    CONFIG
-
-    sample_one("type" => "noop", "@metadata" => {"f1" => "one", "f2" => { "f3" => "three"}, "f4" => { "f5" => "five", "f6" => "six"}, "f7" => "seven"}) do
-      expect(subject.include?("[@metadata][f1]")).to be_falsey
-      expect(subject.include?("[@metadata][f2]")).to be_falsey
-      expect(subject.include?("[@metadata][f4]")).to be_truthy
-      expect(subject.include?("[@metadata][f4][f5]")).to be_falsey
-      expect(subject.include?("[@metadata][f4][f6]")).to be_truthy
-      expect(subject.include?("[@metadata][f7]")).to be_truthy
-    end
-  end
-
-  describe "remove_field on @metadata" do
-    config <<-CONFIG
-    filter {
-      noop {
-        remove_field => ["[@metadata]"]
-      }
-    }
-    CONFIG
-
-    sample_one("type" => "noop", "@metadata" => {"f1" => "one", "f2" => { "f3" => "three"}}) do
-      expect(subject.include?("[@metadata]")).to be_truthy
-      expect(subject.include?("[@metadata][f1]")).to be_falsey
-      expect(subject.include?("[@metadata][f2]")).to be_falsey
-    end
-  end
-
  describe "remove_field on array" do
     config <<-CONFIG
     filter {
@@ -345,17 +310,16 @@ describe LogStash::Filters::NOOP do
     end
   end
 
-  describe "when metrics are disabled" do
-    describe "An error should not be raised, and the event should be processed" do
-      config <<-CONFIG
-        filter {
-          noop { enable_metric => false }
-        }
-      CONFIG
+  describe "when neither add_tag nor remove_tag is specified, the tags field is left untouched" do
+    config <<-CONFIG
+    filter {
+      noop {}
+    }
+    CONFIG
 
-      sample_one("type" => "noop", "tags" => ["go"]) do
-        expect(subject.get("tags")).to eq(["go"])
-      end
+    sample_one("type" => "noop", "go" => "away", "tags" => {"blackhole" => "go"}) do
+      expect(subject.get("[tags][blackhole]")).to eq("go")
     end
+
   end
 end

data/spec/logstash/instrument/periodic_poller/cgroup_spec.rb

@@ -2,6 +2,8 @@
 require "logstash/instrument/periodic_poller/cgroup"
 require "spec_helper"
 
+LogStash::Logging::Logger::configure_logging("DEBUG")
+
 module LogStash module Instrument module PeriodicPoller
 describe "cgroup stats" do
   let(:relative_path) { "/docker/a1f61" }

data/spec/logstash/instrument/wrapped_write_client_spec.rb

@@ -110,7 +110,7 @@ describe LogStash::WrappedWriteClient do
 
   context "WrappedAckedQueue" do
     let(:path) { Stud::Temporary.directory }
-    let(:queue) { LogStash::WrappedAckedQueue.new(path, 1024, 10, 1024, 1024, 1024, false, 4096) }
+    let(:queue) { LogStash::WrappedAckedQueue.new(path, 1024, 10, 1024, 1024, 1024, 4096) }
 
     before do
       read_client.set_events_metric(metric.namespace([:stats, :events]))

data/spec/logstash/java_filter_delegator_spec.rb

@@ -6,7 +6,7 @@ require "support/shared_contexts"
 
 java_import org.logstash.RubyUtil
 
-describe LogStash::FilterDelegator do
+describe LogStash::JavaFilterDelegator do
 
   class MockGauge
     def increment(_)
@@ -182,4 +182,14 @@ describe LogStash::FilterDelegator do
     end
   end
 
+  context "delegate methods to the original plugin" do
+    # I am not testing the behavior of these methods
+    # this is done in the plugin tests. I just want to make sure
+    # the proxy delegates the methods.
+    LogStash::FilterDelegator::DELEGATED_METHODS.each do |method|
+      it "delegate method: `#{method}` to the filter" do
+        expect(subject.respond_to?(method))
+      end
+    end
+  end
 end

data/spec/logstash/legacy_ruby_event_spec.rb

@@ -82,7 +82,7 @@ describe LogStash::Event do
         expect(event.get("reference_test")).not_to eq(data)
       end
 
-      it "should not return an Integer reference" do
+      it "should not return a Fixnum reference" do
         data = 1
         event = LogStash::Event.new({ "reference" => data })
         LogStash::Util::Decorators.add_fields({"reference_test" => "%{reference}"}, event, "dummy-plugin")
@@ -98,12 +98,11 @@ describe LogStash::Event do
         expect(subject.sprintf("bonjour")).to eq("bonjour")
       end
 
-      it "should not raise error and should format as empty string when @timestamp field is missing" do
+      it "should raise error when formatting %{+%s} when @timestamp field is missing" do
         str = "hello-%{+%s}"
         subj = subject.clone
         subj.remove("[@timestamp]")
-        expect{ subj.sprintf(str) }.not_to raise_error(LogStash::Error)
-        expect(subj.sprintf(str)).to eq("hello-")
+        expect{ subj.sprintf(str) }.to raise_error(LogStash::Error)
       end
 
       it "should report a time with %{+format} syntax", :if => RUBY_ENGINE == "jruby" do
@@ -116,11 +115,11 @@ describe LogStash::Event do
         expect(subject.sprintf("foo %{+YYYY-MM-dd} %{type}")).to eq("foo 2013-01-01 sprintf")
       end
 
-      it "should not raise error with %{+format} syntax when @timestamp field is missing", :if => RUBY_ENGINE == "jruby" do
+      it "should raise error with %{+format} syntax when @timestamp field is missing", :if => RUBY_ENGINE == "jruby" do
         str = "logstash-%{+YYYY}"
         subj = subject.clone
         subj.remove("[@timestamp]")
-        expect{ subj.sprintf(str) }.not_to raise_error(LogStash::Error)
+        expect{ subj.sprintf(str) }.to raise_error(LogStash::Error)
       end
 
       it "should report fields with %{field} syntax" do

data/spec/logstash/patches_spec.rb

@@ -36,7 +36,9 @@ describe "OpenSSL defaults" do
     # https://github.com/jordansissel/ruby-flores/blob/master/spec/flores/pki_integration_spec.rb
     # since these helpers were created to fix this particular issue
     let(:csr) { Flores::PKI::CertificateSigningRequest.new }
-    let(:key_bits) { 2048 }
+    # Here, I use a 1024-bit key for faster tests.
+    # Please do not use such small keys in production.
+    let(:key_bits) { 1024 }
     let(:key) { OpenSSL::PKey::RSA.generate(key_bits, 65537) }
     let(:certificate_duration) { Flores::Random.number(1..86400) }
 

data/spec/logstash/pipeline_action/create_spec.rb

@@ -2,14 +2,13 @@
 require "spec_helper"
 require_relative "../../support/helpers"
 require_relative "../../support/matchers"
-require "logstash/pipelines_registry"
 require "logstash/pipeline_action/create"
 require "logstash/inputs/generator"
 
 describe LogStash::PipelineAction::Create do
   let(:metric) { LogStash::Instrument::NullMetric.new(LogStash::Instrument::Collector.new) }
-  let(:pipeline_config) { mock_pipeline_config(:main, "input { dummyblockinginput { id => '123' } } output { null {} }") }
-  let(:pipelines) { LogStash::PipelinesRegistry.new }
+  let(:pipeline_config) { mock_pipeline_config(:main, "input { generator { id => '123' } } output { null {} }") }
+  let(:pipelines) { java.util.concurrent.ConcurrentHashMap.new }
   let(:agent) { double("agent") }
 
   before do
@@ -19,7 +18,7 @@ describe LogStash::PipelineAction::Create do
   subject { described_class.new(pipeline_config, metric) }
 
   after do
-    pipelines.running_pipelines do |_, pipeline|
+    pipelines.each do |_, pipeline|
       pipeline.shutdown
       pipeline.thread.join
     end
@@ -34,32 +33,28 @@ describe LogStash::PipelineAction::Create do
     let(:pipeline_config) { mock_pipeline_config(:main, "input { generator { count => 1 } } output { null {} }") }
 
     it "returns a successful execution status" do
-      allow(agent).to receive(:exclusive) { |&arg| arg.call }
       expect(subject.execute(agent, pipelines)).to be_truthy
     end
   end
 
   context "when the pipeline successfully start" do
     it "adds the pipeline to the current pipelines" do
-      allow(agent).to receive(:exclusive) { |&arg| arg.call }
       expect { subject.execute(agent, pipelines) }.to change(pipelines, :size).by(1)
     end
 
     it "starts the pipeline" do
-      allow(agent).to receive(:exclusive) { |&arg| arg.call }
       subject.execute(agent, pipelines)
-      expect(pipelines.get_pipeline(:main).running?).to be_truthy
+      expect(pipelines[:main].running?).to be_truthy
     end
 
     it "returns a successful execution status" do
-      allow(agent).to receive(:exclusive) { |&arg| arg.call }
       expect(subject.execute(agent, pipelines)).to be_truthy
     end
   end
 
   context  "when the pipeline doesn't start" do
     context "with a syntax error" do
-      let(:pipeline_config) { mock_pipeline_config(:main, "input { dummyblockinginput { id => '123' } } output { stdout ") } # bad syntax
+      let(:pipeline_config) { mock_pipeline_config(:main, "input { generator { id => '123' } } output { stdout ") } # bad syntax
 
       it "raises the exception upstream" do
         expect { subject.execute(agent, pipelines) }.to raise_error
@@ -67,18 +62,17 @@ describe LogStash::PipelineAction::Create do
     end
 
     context "with an error raised during `#register`" do
-      let(:pipeline_config) { mock_pipeline_config(:main, "input { dummyblockinginput { id => '123' } } filter { ruby { init => '1/0' code => '1+2' } } output { null {} }") }
+      let(:pipeline_config) { mock_pipeline_config(:main, "input { generator { id => '123' } } filter { ruby { init => '1/0' code => '1+2' } } output { null {} }") }
 
       it "returns false" do
-        allow(agent).to receive(:exclusive) { |&arg| arg.call }
         expect(subject.execute(agent, pipelines)).not_to be_a_successful_action
       end
     end
   end
 
   context "when sorting create action" do
-    let(:pipeline_config) { mock_pipeline_config(:main, "input { dummyblockinginput { id => '123' } } output { null {} }") }
-    let(:system_pipeline_config) { mock_pipeline_config(:main_2, "input { dummyblockinginput { id => '123' } } output { null {} }", { "pipeline.system" => true }) }
+    let(:pipeline_config) { mock_pipeline_config(:main, "input { generator { id => '123' } } output { null {} }") }
+    let(:system_pipeline_config) { mock_pipeline_config(:main_2, "input { generator { id => '123' } } output { null {} }", { "pipeline.system" => true }) }
 
     it "should give higher priority to system pipeline" do
       action_user_pipeline = described_class.new(pipeline_config, metric)

data/spec/logstash/pipeline_action/reload_spec.rb

@@ -2,16 +2,15 @@
 require "spec_helper"
 require_relative "../../support/helpers"
 require_relative "../../support/matchers"
-require "logstash/pipelines_registry"
 require "logstash/pipeline_action/reload"
 
 describe LogStash::PipelineAction::Reload do
   let(:metric) { LogStash::Instrument::NullMetric.new(LogStash::Instrument::Collector.new) }
   let(:pipeline_id) { :main }
-  let(:new_pipeline_config) { mock_pipeline_config(pipeline_id, "input { dummyblockinginput { id => 'new' } } output { null {} }", { "pipeline.reloadable" => true}) }
-  let(:pipeline_config) { "input { dummyblockinginput {} } output { null {} }" }
+  let(:new_pipeline_config) { mock_pipeline_config(pipeline_id, "input { generator { id => 'new' } } output { null {} }", { "pipeline.reloadable" => true}) }
+  let(:pipeline_config) { "input { generator {} } output { null {} }" }
   let(:pipeline) { mock_pipeline_from_string(pipeline_config, mock_settings("pipeline.reloadable" => true)) }
-  let(:pipelines) { r = LogStash::PipelinesRegistry.new; r.create_pipeline(pipeline_id, pipeline) { true }; r }
+  let(:pipelines) { chm = java.util.concurrent.ConcurrentHashMap.new; chm[pipeline_id] = pipeline; chm }
   let(:agent) { double("agent") }
 
   subject { described_class.new(new_pipeline_config, metric) }
@@ -22,7 +21,7 @@ describe LogStash::PipelineAction::Reload do
   end
 
   after do
-    pipelines.running_pipelines do |_, pipeline|
+    pipelines.each do |_, pipeline|
       pipeline.shutdown
       pipeline.thread.join
     end
@@ -34,20 +33,17 @@ describe LogStash::PipelineAction::Reload do
 
   context "when existing pipeline and new pipeline are both reloadable" do
     it "stop the previous pipeline" do
-      allow(agent).to receive(:exclusive) { |&arg| arg.call }
       expect { subject.execute(agent, pipelines) }.to change(pipeline, :running?).from(true).to(false)
     end
 
     it "start the new pipeline" do
-      allow(agent).to receive(:exclusive) { |&arg| arg.call }
       subject.execute(agent, pipelines)
-      expect(pipelines.get_pipeline(pipeline_id).running?).to be_truthy
+      expect(pipelines[pipeline_id].running?).to be_truthy
     end
 
     it "run the new pipeline code" do
-      allow(agent).to receive(:exclusive) { |&arg| arg.call }
       subject.execute(agent, pipelines)
-      expect(pipelines.get_pipeline(pipeline_id).config_hash).to eq(new_pipeline_config.config_hash)
+      expect(pipelines[pipeline_id].config_hash).to eq(new_pipeline_config.config_hash)
     end
   end
 
@@ -62,30 +58,27 @@ describe LogStash::PipelineAction::Reload do
   end
 
   context "when the new pipeline is not reloadable" do
-    let(:new_pipeline_config) { mock_pipeline_config(pipeline_id, "input { dummyblockinginput { id => 'new' } } output { null {} }", { "pipeline.reloadable" => false}) }
+    let(:new_pipeline_config) { mock_pipeline_config(pipeline_id, "input { generator { id => 'new' } } output { null {} }", { "pipeline.reloadable" => false}) }
 
     it "cannot successfully execute the action" do
-      allow(agent).to receive(:exclusive) { |&arg| arg.call }
       expect(subject.execute(agent, pipelines)).not_to be_a_successful_action
     end
   end
 
   context "when the new pipeline has syntax errors" do
-    let(:new_pipeline_config) { mock_pipeline_config(pipeline_id, "input dummyblockinginput { id => 'new' } } output { null {} }", { "pipeline.reloadable" => false}) }
+    let(:new_pipeline_config) { mock_pipeline_config(pipeline_id, "input generator { id => 'new' } } output { null {} }", { "pipeline.reloadable" => false}) }
 
     it "cannot successfully execute the action" do
-      allow(agent).to receive(:exclusive) { |&arg| arg.call }
       expect(subject.execute(agent, pipelines)).not_to be_a_successful_action
     end
   end
 
   context "when there is an error in the register" do
     before do
-      allow_any_instance_of(LogStash::Inputs::DummyBlockingInput).to receive(:register).and_raise("Bad value")
+      allow_any_instance_of(LogStash::Inputs::Generator).to receive(:register).and_raise("Bad value")
     end
 
     it "cannot successfully execute the action" do
-      allow(agent).to receive(:exclusive) { |&arg| arg.call }
       expect(subject.execute(agent, pipelines)).not_to be_a_successful_action
     end
   end

data/spec/logstash/pipeline_action/stop_spec.rb

@@ -1,15 +1,14 @@
 # encoding: utf-8
 require "spec_helper"
 require_relative "../../support/helpers"
-require "logstash/pipelines_registry"
 require "logstash/pipeline_action/stop"
 require "logstash/pipeline"
 
 describe LogStash::PipelineAction::Stop do
-  let(:pipeline_config) { "input { dummyblockinginput {} } output { null {} }" }
+  let(:pipeline_config) { "input { generator {} } output { null {} }" }
   let(:pipeline_id) { :main }
   let(:pipeline) { mock_pipeline_from_string(pipeline_config) }
-  let(:pipelines) { chm = LogStash::PipelinesRegistry.new; chm.create_pipeline(pipeline_id, pipeline) { true }; chm }
+  let(:pipelines) { chm = java.util.concurrent.ConcurrentHashMap.new; chm[:main] = pipeline; chm }
   let(:agent) { double("agent") }
 
   subject { described_class.new(pipeline_id) }
@@ -32,6 +31,6 @@ describe LogStash::PipelineAction::Stop do
   end
 
   it "removes the pipeline from the running pipelines" do
-    expect { subject.execute(agent, pipelines) }.to change { pipelines.running_pipelines.keys }.from([:main]).to([])
+    expect { subject.execute(agent, pipelines) }.to change { pipelines.include?(pipeline_id) }.from(true).to(false)
   end
 end

data/spec/logstash/queue_factory_spec.rb

@@ -14,7 +14,6 @@ describe LogStash::QueueFactory do
       LogStash::Setting::Numeric.new("queue.checkpoint.acks", 1024),
       LogStash::Setting::Numeric.new("queue.checkpoint.writes", 1024),
       LogStash::Setting::Numeric.new("queue.checkpoint.interval", 1000),
-      LogStash::Setting::Boolean.new("queue.checkpoint.retry", false),
       LogStash::Setting::String.new("pipeline.id", pipeline_id),
       LogStash::Setting::PositiveInteger.new("pipeline.batch.size", 125),
       LogStash::Setting::PositiveInteger.new("pipeline.workers", LogStash::Config::CpuCoreStrategy.maximum)
@@ -47,7 +46,7 @@ describe LogStash::QueueFactory do
       let(:queue_path) { ::File.join(settings.get("path.queue"), pipeline_id) }
 
       after :each do
-        FileUtils.rm_rf(queue_path)
+        FileUtils.rmdir(queue_path)
       end
 
       it "creates a queue directory based on the pipeline id" do

data/spec/logstash/runner_spec.rb

@@ -22,8 +22,6 @@ describe LogStash::Runner do
   before :each do
     clear_data_dir
 
-    WebMock.disable_net_connect!(allow_localhost: true)
-
     allow(LogStash::Runner).to receive(:logger).and_return(logger)
     allow(logger).to receive(:debug?).and_return(true)
     allow(logger).to receive(:subscribe).with(any_args)

data/spec/logstash/settings/array_coercible_spec.rb

@@ -27,7 +27,7 @@ describe LogStash::Setting::ArrayCoercible do
 
   describe "initialization" do
     subject { described_class }
-    let(:element_class) { Integer }
+    let(:element_class) { Fixnum }
     context "when given values of incorrect element class" do
       let(:value) { "test" }
 

data/spec/logstash/settings/bytes_spec.rb

@@ -35,8 +35,8 @@ describe LogStash::Setting::Bytes do
 
         before { subject.set(text) }
 
-        it "should coerce it to an Integer" do
-          expect(subject.value).to be_a(::Integer)
+        it "should coerce it to a Fixnum" do
+          expect(subject.value).to be_a(Fixnum)
         end
       end
 

data/spec/logstash/settings/port_range_spec.rb

@@ -5,7 +5,7 @@ require "spec_helper"
 
 describe LogStash::Setting::PortRange do
 
-  context "When the value is an Integer" do
+  context "When the value is a Fixnum" do
     subject { LogStash::Setting::PortRange.new("mynewtest", 9000) }
 
     it "coerces the value in a range" do

data/spec/logstash/settings_spec.rb

@@ -158,11 +158,6 @@ describe LogStash::Settings do
 
     before :each do
       LogStash::SETTINGS.set("keystore.file", File.join(File.dirname(__FILE__), "../../src/test/resources/logstash.keystore.with.default.pass"))
-      LogStash::Util::SubstitutionVariables.send(:reset_secret_store)
-    end
-
-    after(:each) do
-      LogStash::Util::SubstitutionVariables.send(:reset_secret_store)
     end
 
     context "placeholders in flat logstash.yml" do
@@ -216,7 +211,6 @@ describe LogStash::Settings do
 
     before :each do
       LogStash::SETTINGS.set("keystore.file", File.join(File.dirname(__FILE__), "../../src/test/resources/logstash.keystore.with.default.pass"))
-      LogStash::Util::SubstitutionVariables.send(:reset_secret_store)
     end
 
     before do
@@ -231,10 +225,6 @@ describe LogStash::Settings do
       ENV.delete('a')
     end
 
-    after(:each) do
-      LogStash::Util::SubstitutionVariables.send(:reset_secret_store)
-    end
-
     subject do
       settings = described_class.new
       settings.register(LogStash::Setting::ArrayCoercible.new("host", String, []))

data/spec/logstash/state_resolver_spec.rb

@@ -18,17 +18,17 @@ describe LogStash::StateResolver do
 
   after do
     # ensure that the the created pipeline are closed
-    pipelines.running_pipelines.each { |_, pipeline| pipeline.close }
+    running_pipelines.each { |_, pipeline| pipeline.close }
   end
 
   context "when no pipeline is running" do
-    let(:pipelines) {  LogStash::PipelinesRegistry.new }
+    let(:running_pipelines) { {} }
 
     context "no pipeline configs is received" do
       let(:pipeline_configs) { [] }
 
       it "returns no action" do
-        expect(subject.resolve(pipelines, pipeline_configs).size).to eq(0)
+        expect(subject.resolve(running_pipelines, pipeline_configs).size).to eq(0)
       end
     end
 
@@ -36,7 +36,7 @@ describe LogStash::StateResolver do
       let(:pipeline_configs) { [mock_pipeline_config(:hello_world)] }
 
       it "returns some actions" do
-        expect(subject.resolve(pipelines, pipeline_configs)).to have_actions(
+        expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
           [:create, :hello_world],
         )
       end
@@ -47,17 +47,13 @@ describe LogStash::StateResolver do
     context "when a pipeline is running" do
       let(:main_pipeline) { mock_pipeline(:main) }
       let(:main_pipeline_config) { main_pipeline.pipeline_config }
-      let(:pipelines) do
-        r =  LogStash::PipelinesRegistry.new
-        r.create_pipeline(:main, main_pipeline) { true }
-        r
-      end
+      let(:running_pipelines) { { :main => main_pipeline } }
 
       context "when the pipeline config contains a new one and the existing" do
         let(:pipeline_configs) { [mock_pipeline_config(:hello_world), main_pipeline_config ] }
 
         it "creates the new one and keep the other one" do
-          expect(subject.resolve(pipelines, pipeline_configs)).to have_actions(
+          expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
             [:create, :hello_world],
           )
         end
@@ -66,7 +62,7 @@ describe LogStash::StateResolver do
           let(:pipeline_configs) { [mock_pipeline_config(:hello_world)] }
 
           it "creates the new one and stop the old one one" do
-            expect(subject.resolve(pipelines, pipeline_configs)).to have_actions(
+            expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
               [:create, :hello_world],
               [:stop, :main]
             )
@@ -77,7 +73,7 @@ describe LogStash::StateResolver do
           let(:pipeline_configs) { [] }
 
           it "stops the old one one" do
-            expect(subject.resolve(pipelines, pipeline_configs)).to have_actions(
+            expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
               [:stop, :main]
             )
           end
@@ -87,7 +83,7 @@ describe LogStash::StateResolver do
           let(:pipeline_configs) { [mock_pipeline_config(:main, "input { generator {}}")] }
 
           it "reloads the old one one" do
-            expect(subject.resolve(pipelines, pipeline_configs)).to have_actions(
+            expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
               [:reload, :main]
             )
           end
@@ -96,21 +92,21 @@ describe LogStash::StateResolver do
     end
 
     context "when we have a lot of pipeline running" do
-      let(:pipelines) do
-        r =  LogStash::PipelinesRegistry.new
-        r.create_pipeline(:main1, mock_pipeline(:main1)) { true }
-        r.create_pipeline(:main2, mock_pipeline(:main2)) { true }
-        r.create_pipeline(:main3, mock_pipeline(:main3)) { true }
-        r.create_pipeline(:main4, mock_pipeline(:main4)) { true }
-        r.create_pipeline(:main5, mock_pipeline(:main5)) { true }
-        r.create_pipeline(:main6, mock_pipeline(:main6)) { true }
-        r
+      let(:running_pipelines) do
+        {
+          :main1 => mock_pipeline(:main1),
+          :main2 => mock_pipeline(:main2),
+          :main3 => mock_pipeline(:main3),
+          :main4 => mock_pipeline(:main4),
+          :main5 => mock_pipeline(:main5),
+          :main6 => mock_pipeline(:main6),
+        }
       end
 
       context "without system pipeline" do
         let(:pipeline_configs) do
           [
-            pipelines.get_pipeline(:main1).pipeline_config,
+            running_pipelines[:main1].pipeline_config,
             mock_pipeline_config(:main9),
             mock_pipeline_config(:main5, "input { generator {}}"),
             mock_pipeline_config(:main3, "input { generator {}}"),
@@ -119,7 +115,7 @@ describe LogStash::StateResolver do
         end
 
         it "generates actions required to converge" do
-          expect(subject.resolve(pipelines, pipeline_configs)).to have_actions(
+          expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
             [:create, :main7],
             [:create, :main9],
             [:reload, :main3],
@@ -134,7 +130,7 @@ describe LogStash::StateResolver do
       context "with system pipeline" do
         let(:pipeline_configs) do
           [
-            pipelines.get_pipeline(:main1).pipeline_config,
+            running_pipelines[:main1].pipeline_config,
             mock_pipeline_config(:main9),
             mock_pipeline_config(:main5, "input { generator {}}"),
             mock_pipeline_config(:main3, "input { generator {}}"),
@@ -144,7 +140,7 @@ describe LogStash::StateResolver do
         end
 
         it "creates the system pipeline before user defined pipelines" do
-          expect(subject.resolve(pipelines, pipeline_configs)).to have_actions(
+          expect(subject.resolve(running_pipelines, pipeline_configs)).to have_actions(
             [:create, :monitoring],
             [:create, :main7],
             [:create, :main9],

data/spec/logstash/util/safe_uri_spec.rb

@@ -32,45 +32,5 @@ module LogStash module Util
         end
       end
     end
-
-    describe "#initialize" do
-      context 'when host is required' do
-        MALFORMED_URIS = ['http:/user:pass@localhost:9600', 'http:/localhost', 'http:/localhost:9600', 'h;localhost', 'http:://localhost']
-
-        context 'malformed uris via string' do
-          MALFORMED_URIS.each do |arg|
-            it "#{arg}: should raise an error" do
-              expect{LogStash::Util::SafeURI.new(arg)}.to raise_error(ArgumentError)
-            end
-          end
-        end
-
-        context 'malformed uris via java.net.URI' do
-          MALFORMED_URIS.each do |arg|
-            it "#{arg}: should raise an error" do
-              java_uri = java.net.URI.new(arg)
-              expect{LogStash::Util::SafeURI.new(java_uri)}.to raise_error(ArgumentError)
-            end
-          end
-        end
-
-        context 'malformed uris via Ruby URI' do
-          MALFORMED_URIS.each do |arg|
-            it "#{arg}: should raise an error" do
-              ruby_uri = URI.parse(arg)
-              expect{LogStash::Util::SafeURI.new(ruby_uri)}.to raise_error(ArgumentError)
-            end
-          end
-        end
-
-        context 'uris with a valid host' do
-          ['http://user:pass@notlocalhost:9600', 'http://notlocalhost', 'https://notlocalhost:9600', '//notlocalhost', 'notlocalhost', 'notlocalhost:9200'].each do |arg|
-            it "#{arg}: should resolve host correctly" do
-              expect(LogStash::Util::SafeURI.new(arg).host).to eq('notlocalhost')
-            end
-          end
-        end
-      end
-    end
   end
 end end

data/spec/logstash/util/secretstore_spec.rb

@@ -12,7 +12,7 @@ describe SecretStoreExt do
     end
 
     it "should be not exist" do
-      expect(subject.exists(LogStash::SETTINGS.get_setting("keystore.file").value, LogStash::SETTINGS.get_setting("keystore.classname").value)).to be_falsy
+      expect(subject.exists(LogStash::SETTINGS.get_setting("keystore.file").value, LogStash::SETTINGS.get_setting("keystore.classname").value)).to be_falsey
       expect(subject.getIfExists(LogStash::SETTINGS.get_setting("keystore.file").value, LogStash::SETTINGS.get_setting("keystore.classname").value)).to be_nil
     end
   end

data/spec/logstash/util/time_value_spec.rb

@@ -51,7 +51,7 @@ describe TimeValue do
         a = TimeValue.from_value(32)
         fail "should not parse"
       rescue ArgumentError => e
-        expect(e.message).to eq("value is not a string: 32 [Integer]")
+        expect(e.message).to eq("value is not a string: 32 [Fixnum]")
       end
     end
 end