logstash-core 6.0.0.alpha2-java → 6.0.0.beta1-java

data/spec/logstash/config/config_ast_spec.rb

@@ -6,6 +6,8 @@ require "logstash/config/grammar"
 require "logstash/config/config_ast"
 
 describe LogStashConfigParser do
+  let(:settings) { mock_settings({}) }
+
   context '#parse' do
     context "valid configuration" do
       it "should permit single-quoted attribute names" do
@@ -77,7 +79,7 @@ describe LogStashConfigParser do
         }
       CONFIG
       subject { LogStashConfigParser.new }
-         
+
       it "should compile successfully" do
         result = subject.parse(config)
         expect(result).not_to(be_nil)
@@ -142,12 +144,50 @@ describe LogStashConfigParser do
         expect(config).to be_nil
       end
     end
+
+    context "when config.support_escapes" do
+      let(:parser) { LogStashConfigParser.new }
+
+      let(:processed_value)  { 'The computer says, "No"' }
+
+      let(:config) {
+        parser.parse(%q(
+          input {
+            foo {
+              bar => "The computer says, \"No\""
+            }
+          }
+        ))
+      }
+
+      let(:compiled_string) { eval(config.recursive_select(LogStash::Config::AST::String).first.compile) }
+
+      before do
+        config.process_escape_sequences = escapes
+      end
+
+      context "is enabled" do
+        let(:escapes) { true }
+
+        it "should process escape sequences" do
+          expect(compiled_string).to be == processed_value
+        end
+      end
+
+      context "is false" do
+        let(:escapes) { false }
+
+        it "should not process escape sequences" do
+          expect(compiled_string).not_to be == processed_value
+        end
+      end
+    end
   end
 
   context "when using two plugin sections of the same type" do
     let(:pipeline_klass) do
       Class.new do
-        def initialize(config)
+        def initialize(config, settings)
           grammar = LogStashConfigParser.new
           @config = grammar.parse(config)
           @code = @config.compile
@@ -166,7 +206,7 @@ describe LogStashConfigParser do
 
 
       it "should create a pipeline with both sections" do
-        generated_objects = pipeline_klass.new(config_string).instance_variable_get("@generated_objects")
+        generated_objects = pipeline_klass.new(config_string, settings).instance_variable_get("@generated_objects")
         filters = generated_objects.keys.map(&:to_s).select {|obj_name| obj_name.match(/^filter.+?_\d+$/) }
         expect(filters.size).to eq(2)
       end
@@ -181,14 +221,13 @@ describe LogStashConfigParser do
 
 
       it "should create a pipeline with both sections" do
-        generated_objects = pipeline_klass.new(config_string).instance_variable_get("@generated_objects")
+        generated_objects = pipeline_klass.new(config_string, settings).instance_variable_get("@generated_objects")
         outputs = generated_objects.keys.map(&:to_s).select {|obj_name| obj_name.match(/^output.+?_\d+$/) }
         expect(outputs.size).to eq(2)
       end
     end
   end
   context "when creating two instances of the same configuration" do
-
     let(:config_string) {
       "input { generator { } }
        filter {
@@ -201,7 +240,7 @@ describe LogStashConfigParser do
 
     let(:pipeline_klass) do
       Class.new do
-        def initialize(config)
+        def initialize(config, settings)
           grammar = LogStashConfigParser.new
           @config = grammar.parse(config)
           @code = @config.compile
@@ -213,8 +252,8 @@ describe LogStashConfigParser do
 
     describe "generated conditional functionals" do
       it "should be created per instance" do
-        instance_1 = pipeline_klass.new(config_string)
-        instance_2 = pipeline_klass.new(config_string)
+        instance_1 = pipeline_klass.new(config_string, settings)
+        instance_2 = pipeline_klass.new(config_string, settings)
         generated_method_1 = instance_1.instance_variable_get("@generated_objects")[:cond_func_1]
         generated_method_2 = instance_2.instance_variable_get("@generated_objects")[:cond_func_1]
         expect(generated_method_1).to_not be(generated_method_2)

data/spec/logstash/config/mixin_spec.rb

@@ -192,8 +192,8 @@ describe LogStash::Config::Mixin do
         expect(clone.uri.to_s).to eql(uri_hidden)
       end
 
-      it "should make the real URI object available under #uri" do
-        expect(subject.uri.uri).to be_a(::URI)
+      it "should make the real java.net.URI object available under #uri" do
+        expect(subject.uri.uri).to be_a(java.net.URI)
       end
 
       it "should obfuscate original_params" do
@@ -369,11 +369,13 @@ describe LogStash::Config::Mixin do
       before do
         ENV["FunString"] = "fancy"
         ENV["FunBool"] = "true"
+        ENV["SERVER_LS_TEST_ADDRESS"] = "some.host.address.tld"
       end
 
       after do
         ENV.delete("FunString")
         ENV.delete("FunBool")
+        ENV.delete("SERVER_LS_TEST_ADDRESS")
       end
 
       subject do
@@ -397,6 +399,16 @@ describe LogStash::Config::Mixin do
         expect(subject.nestedArray).to(be == { "level1" => [{ "key1" => "http://fancy:8080/blah.txt" }, { "key2" => "http://fancy:8080/foo.txt" }] })
         expect(subject.deepHash).to(be == { "level1" => { "level2" => { "level3" => { "key1" => "http://fancy:8080/blah.txt" } } } })
       end
+
+      it "should validate settings after interpolating ENV variables" do
+        expect {
+          Class.new(LogStash::Filters::Base) do
+            include LogStash::Config::Mixin
+            config_name "test"
+            config :server_address, :validate => :uri
+          end.new({"server_address" => "${SERVER_LS_TEST_ADDRESS}"})
+        }.not_to raise_error
+      end
     end
 
     context "should support $ in values" do

data/spec/logstash/config/pipeline_config_spec.rb

@@ -7,13 +7,13 @@ describe LogStash::Config::PipelineConfig do
   let(:pipeline_id) { :main }
   let(:ordered_config_parts) do
     [
-      org.logstash.common.SourceWithMetadata.new("file", "/tmp/1", "input { generator1 }"),
-      org.logstash.common.SourceWithMetadata.new("file", "/tmp/2", "input { generator2 }"),
-      org.logstash.common.SourceWithMetadata.new("file", "/tmp/3", "input { generator3 }"),
-      org.logstash.common.SourceWithMetadata.new("file", "/tmp/4", "input { generator4 }"),
-      org.logstash.common.SourceWithMetadata.new("file", "/tmp/5", "input { generator5 }"),
-      org.logstash.common.SourceWithMetadata.new("file", "/tmp/6", "input { generator6 }"),
-      org.logstash.common.SourceWithMetadata.new("string", "config_string", "input { generator1 }"),
+      org.logstash.common.SourceWithMetadata.new("file", "/tmp/1", 0, 0, "input { generator1 }"),
+      org.logstash.common.SourceWithMetadata.new("file", "/tmp/2", 0, 0,  "input { generator2 }"),
+      org.logstash.common.SourceWithMetadata.new("file", "/tmp/3", 0, 0, "input { generator3 }"),
+      org.logstash.common.SourceWithMetadata.new("file", "/tmp/4", 0, 0, "input { generator4 }"),
+      org.logstash.common.SourceWithMetadata.new("file", "/tmp/5", 0, 0, "input { generator5 }"),
+      org.logstash.common.SourceWithMetadata.new("file", "/tmp/6", 0, 0, "input { generator6 }"),
+      org.logstash.common.SourceWithMetadata.new("string", "config_string", 0, 0, "input { generator1 }"),
     ]
   end
 

data/spec/logstash/config/source/local_spec.rb

@@ -288,13 +288,15 @@ describe LogStash::Config::Source::Local do
     let(:settings) do
       mock_settings(
         "config.string" => "#{filter_block} #{output_block}",
-        "path.config" => config_file
+        "path.config" => config_file,
+        "modules.cli" => [],
+        "modules" => []
       )
     end
 
     # this should be impossible as the bootstrap checks should catch this
     it "raises an exception" do
-      expect { subject.pipeline_configs }.to raise_error
+      expect { subject.pipeline_configs }.to raise_error(LogStash::ConfigurationError)
     end
   end
 
@@ -367,6 +369,7 @@ describe LogStash::Config::Source::Local do
         file = Stud::Temporary.file
         path = file.path
         file.write(config_string)
+        file.close # we need to flush the write
         path
       end
       let(:settings) { mock_settings( "path.config" => config_path) }

data/spec/logstash/config/source/multi_local_spec.rb

@@ -18,10 +18,52 @@ describe LogStash::Config::Source::MultiLocal do
     allow(subject).to receive(:pipelines_yaml_location).and_return(pipelines_yaml_location)
   end
 
+  describe "#config_conflict?" do
+    context "when `config.string` is set" do
+      let(:settings) do
+        mock_settings("config.string" => "input {} output {}")
+      end
+      it "returns false" do
+        expect(subject.config_conflict?).to be_falsey
+        expect(subject.conflict_messages).to be_empty
+      end
+    end
+
+    context "when `config.path` is set" do
+      let(:config_file) { temporary_file("") }
+
+      let(:settings) do
+        mock_settings("path.config" => config_file)
+      end
+      it "returns false" do
+        expect(subject.config_conflict?).to be_falsey
+        expect(subject.conflict_messages).to be_empty
+      end
+    end
+
+    context "when `pipelines.yml` is not set" do
+      let(:pipelines_yaml_location) { ::File.join(Stud::Temporary.pathname, "pipelines.yml") }
+      it "returns true with messages" do
+        expect(subject.config_conflict?).to be_truthy
+        expect(subject.conflict_messages).to include(/Failed to read pipelines yaml file. Location:/)
+      end
+    end
+
+    context "when `pipelines.yml` is only comments" do
+      before(:each) do
+        allow(subject).to receive(:read_pipelines_from_yaml).and_return(::YAML.load("# blah\n# blah\n# blah\n"))
+      end
+      it "returns true with messages" do
+        expect(subject.config_conflict?).to be_truthy
+        expect(subject.conflict_messages).to include(/Pipelines YAML file is empty. Location:/)
+      end
+    end
+  end
+
   describe "#match?" do
     context "when `config.string` is set" do
       let(:settings) do
-        mock_settings("config.string" => "")
+        mock_settings("config.string" => "input {} output {}")
       end
       it "returns false" do
         expect(subject.match?).to be_falsey
@@ -29,7 +71,7 @@ describe LogStash::Config::Source::MultiLocal do
     end
 
     context "when `config.path` are set`" do
-      let(:config_file) { temporary_file("") }
+      let(:config_file) { temporary_file("input {} output {}") }
 
       let(:settings) do
         mock_settings("path.config" => config_file)
@@ -42,27 +84,31 @@ describe LogStash::Config::Source::MultiLocal do
 
     context "when both `config.string` and `path.config` are set" do
       let(:settings) do
-        mock_settings("config.string" => "", "path.config" => temporary_file(""))
+        mock_settings("config.string" => "input {} output {}", "path.config" => temporary_file("input {} output {}"))
       end
       it "returns false" do
         expect(subject.match?).to be_falsey
       end
     end
 
-    context "when neither `config.path` nor `path.config` are set`" do
+    context "when neither `config.path` nor `path.config` are set` and pipelines.yml has configs" do
+      before do
+        allow(subject).to receive(:invalid_pipelines_detected?).and_return(false)
+      end
       it "returns true" do
         expect(subject.match?).to be_truthy
       end
     end
   end
+
   describe "#detect_duplicate_pipelines" do
     let(:retrieved_pipelines) { [{}] }
     let(:retrieved_pipelines_configs) { retrieved_pipelines.map {|h| mock_settings(h) } }
     context "when there are duplicate pipeline ids" do
       let(:retrieved_pipelines) do
         [
-          {"pipeline.id" => "main", "config.string" => ""},
-          {"pipeline.id" => "main", "config.string" => ""},
+          {"pipeline.id" => "main", "config.string" => "input {} output {}"},
+          {"pipeline.id" => "main", "config.string" => "input {} output {}"},
         ]
       end
       it "should raise a ConfigurationError" do
@@ -72,8 +118,8 @@ describe LogStash::Config::Source::MultiLocal do
     context "when there are no duplicate pipeline ids" do
       let(:retrieved_pipelines) do
         [
-          {"pipeline.id" => "main", "config.string" => ""},
-          {"pipeline.id" => "backup", "config.string" => ""},
+          {"pipeline.id" => "main", "config.string" => "input {} output {}"},
+          {"pipeline.id" => "backup", "config.string" => "input {} output {}"},
         ]
       end
       it "should not raise an error" do
@@ -85,8 +131,8 @@ describe LogStash::Config::Source::MultiLocal do
   describe "#pipeline_configs" do
     let(:retrieved_pipelines) do
       [
-        { "pipeline.id" => "main", "config.string" => "" },
-        { "pipeline.id" => "backup", "config.string" => "" }
+        { "pipeline.id" => "main", "config.string" => "input {} output {}" },
+        { "pipeline.id" => "backup", "config.string" => "input {} output {}" }
       ]
     end
     before(:each) do

data/spec/logstash/config/source_loader_spec.rb

@@ -4,7 +4,7 @@ require "logstash/config/source/base"
 require_relative "../../support/helpers"
 
 def temporary_pipeline_config(id, source, reader = "random_reader")
-  config_part = org.logstash.common.SourceWithMetadata.new("local", "...", "input {} output {}")
+  config_part = org.logstash.common.SourceWithMetadata.new("local", "...", 0, 0, "input {} output {}")
   LogStash::Config::PipelineConfig.new(source, id, [config_part], LogStash::SETTINGS)
 end
 

data/spec/logstash/config/string_escape_spec.rb

@@ -0,0 +1,24 @@
+
+require "logstash/config/string_escape"
+
+describe LogStash::Config::StringEscape do
+  let(:result) { described_class.process_escapes(text) }
+
+  table = {
+    '\\"' => '"',
+    "\\'" => "'",
+    "\\n" => "\n",
+    "\\r" => "\r",
+    "\\t" => "\t",
+    "\\\\" => "\\",
+  }
+
+  table.each do |input, expected|
+    context "when processing #{input.inspect}" do
+      let(:text) { input }
+      it "should produce #{expected.inspect}" do
+        expect(result).to be == expected
+      end
+    end
+  end
+end

data/spec/logstash/event_spec.rb

@@ -84,6 +84,15 @@ describe LogStash::Event do
       expect(e.get("foo")).to eq("bar")
     end
 
+    it "should propagate changes to mutable strings to java APIs" do
+      e = LogStash::Event.new()
+      e.to_java.setField("foo", "bar")
+      expect(e.get("foo")).to eq("bar")
+      e.get("foo").gsub!(/bar/, 'pff')
+      expect(e.get("foo")).to eq("pff")
+      expect(e.to_java.getField("foo")).to eq("pff")
+    end
+
     it "should set deep hash values" do
       e = LogStash::Event.new()
       expect(e.set("[foo][bar]", "baz")).to eq("baz")

data/spec/logstash/filters/base_spec.rb

@@ -24,7 +24,7 @@ describe LogStash::Filters::Base do
   end
 
   it "should provide class public API" do
-    [:register, :filter, :multi_filter, :execute, :threadsafe?, :filter_matched, :filter?, :close].each do |method|
+    [:register, :filter, :multi_filter, :execute, :threadsafe?, :close].each do |method|
       expect(subject).to respond_to(method)
     end
   end

data/spec/logstash/instrument/metric_store_spec.rb

@@ -1,6 +1,5 @@
 # encoding: utf-8
 require "logstash/instrument/metric_store"
-require "logstash/instrument/metric_type/base"
 
 describe LogStash::Instrument::MetricStore do
   let(:namespaces) { [ :root, :pipelines, :pipeline_01 ] }
@@ -81,7 +80,7 @@ describe LogStash::Instrument::MetricStore do
 
         it "allow to retrieve a specific metrics" do
           metrics = subject.get(:node, :sashimi, :pipelines, :pipeline01, :plugins, :"logstash-output-elasticsearch", :event_in)
-          expect(metrics).to match(a_hash_including(:node => a_hash_including(:sashimi => a_hash_including(:pipelines  => a_hash_including(:pipeline01 => a_hash_including(:plugins => a_hash_including(:"logstash-output-elasticsearch" => a_hash_including(:event_in => be_kind_of(LogStash::Instrument::MetricType::Base)))))))))
+          expect(metrics).to match(a_hash_including(:node => a_hash_including(:sashimi => a_hash_including(:pipelines  => a_hash_including(:pipeline01 => a_hash_including(:plugins => a_hash_including(:"logstash-output-elasticsearch" => a_hash_including(:event_in => be_kind_of(LogStash::Instrument::MetricType::Counter)))))))))
         end
 
         context "with filtered keys" do
@@ -127,7 +126,7 @@ describe LogStash::Instrument::MetricStore do
 
           it "allow to retrieve a specific metrics" do
             metrics = subject.get_with_path("node/sashimi/pipelines/pipeline01/plugins/logstash-output-elasticsearch/event_in")
-            expect(metrics).to match(a_hash_including(:node => a_hash_including(:sashimi => a_hash_including(:pipelines  => a_hash_including(:pipeline01 => a_hash_including(:plugins => a_hash_including(:"logstash-output-elasticsearch" => a_hash_including(:event_in => be_kind_of(LogStash::Instrument::MetricType::Base)))))))))
+            expect(metrics).to match(a_hash_including(:node => a_hash_including(:sashimi => a_hash_including(:pipelines  => a_hash_including(:pipeline01 => a_hash_including(:plugins => a_hash_including(:"logstash-output-elasticsearch" => a_hash_including(:event_in => be_kind_of(LogStash::Instrument::MetricType::Counter)))))))))
           end
 
           context "with filtered keys" do

data/spec/logstash/instrument/metric_type/counter_spec.rb

@@ -14,22 +14,10 @@ describe LogStash::Instrument::MetricType::Counter do
     end
   end
 
-  describe "#decrement" do
-    it "decrement the counter" do
-      expect{ subject.decrement }.to change { subject.value }.by(-1)
-    end
-  end
-
   context "When serializing to JSON" do
     it "serializes the value" do
       expect(LogStash::Json.dump(subject)).to eq("0")
     end
   end
 
-  context "When creating a hash " do
-    it "creates the hash from all the values" do
-      metric_hash = { key => 0 }
-      expect(subject.to_hash).to match(metric_hash)
-    end
-  end
 end

data/spec/logstash/instrument/metric_type/gauge_spec.rb

@@ -26,12 +26,5 @@ describe LogStash::Instrument::MetricType::Gauge do
     end
   end
 
-  context "When creating a hash " do
-    it "creates the hash from all the values" do
-      metric_hash = {
-        key => value
-      }
-      expect(subject.to_hash).to match(metric_hash)
-    end
-  end
+
 end