logstash-core 2.2.4.snapshot1

data/spec/logstash/environment_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+require "spec_helper"
+require "logstash/environment"
+
+describe LogStash::Environment do
+
+  context "when loading jars dependencies" do
+
+    let(:default_jars_location)    { File.join("vendor", "jar-dependencies") }
+    let(:default_runtime_location) { File.join(default_jars_location,"runtime-jars","*.jar") }
+    let(:default_test_location)    { File.join(default_jars_location,"test-jars","*.jar") }
+
+    it "raises an exception if jruby is not available" do
+      expect(subject).to receive(:jruby?).and_return(false)
+      expect { subject.load_runtime_jars! }.to raise_error
+    end
+
+    it "find runtime jars in the default location" do
+      expect(subject).to receive(:find_jars).with(default_runtime_location).and_return([])
+      subject.load_runtime_jars!
+    end
+
+    it "find test jars in the default location" do
+      expect(subject).to receive(:find_jars).with(default_test_location).and_return([])
+      subject.load_test_jars!
+    end
+
+    context "when loading a jar file" do
+
+      let(:dummy_jar_file) { File.join(default_jars_location,"runtime-jars","elasticsearch.jar") }
+
+      it "requires the jar files if there are jars to load" do
+        expect(subject).to receive(:find_jars).with(default_runtime_location).and_return([dummy_jar_file])
+        expect(subject).to receive(:require).with(dummy_jar_file)
+        subject.load_runtime_jars!
+      end
+
+      it "raises an exception if there are no jars to load" do
+        allow(Dir).to receive(:glob).and_return([])
+        expect { subject.load_runtime_jars! }.to raise_error
+      end
+    end
+  end
+
+  context "add_plugin_path" do
+    let(:path) { "/some/path" }
+
+    before(:each) { expect($LOAD_PATH).to_not include(path) }
+    after(:each) { $LOAD_PATH.delete(path) }
+
+    it "should add the path to $LOAD_PATH" do
+      expect{subject.add_plugin_path(path)}.to change{$LOAD_PATH.size}.by(1)
+      expect($LOAD_PATH).to include(path)
+    end
+  end
+end

data/spec/logstash/filters/base_spec.rb

@@ -0,0 +1,251 @@
+# encoding: utf-8
+require "spec_helper"
+require "logstash/json"
+
+# use a dummy NOOP filter to test Filters::Base
+class LogStash::Filters::NOOP < LogStash::Filters::Base
+  config_name "noop"
+  milestone 2
+
+  def register; end
+
+  def filter(event)
+    return unless filter?(event)
+    filter_matched(event)
+  end
+end
+
+describe LogStash::Filters::Base do
+  subject {LogStash::Filters::Base.new({})}
+
+  it "should provide method interfaces to override" do
+    expect{subject.register}.to raise_error(RuntimeError)
+    expect{subject.filter(:foo)}.to raise_error(RuntimeError)
+  end
+
+  it "should provide class public API" do
+    [:register, :filter, :multi_filter, :execute, :threadsafe?, :filter_matched, :filter?, :close].each do |method|
+      expect(subject).to respond_to(method)
+    end
+  end
+
+  context "multi_filter" do
+    let(:event1){LogStash::Event.new}
+    let(:event2){LogStash::Event.new}
+
+    it "should multi_filter without new events" do
+      allow(subject).to receive(:filter) do |event, &block|
+        nil
+      end
+      expect(subject.multi_filter([event1])).to eq([event1])
+    end
+
+    it "should multi_filter with new events" do
+      allow(subject).to receive(:filter) do |event, &block|
+        block.call(event2)
+      end
+      expect(subject.multi_filter([event1])).to eq([event1, event2])
+    end
+  end
+end
+
+describe LogStash::Filters::NOOP do
+
+  describe "adding multiple values to one field" do
+    config <<-CONFIG
+    filter {
+      noop {
+        add_field => ["new_field", "new_value"]
+        add_field => ["new_field", "new_value_2"]
+      }
+    }
+    CONFIG
+
+    sample "example" do
+      insist { subject["new_field"] } == ["new_value", "new_value_2"]
+    end
+  end
+
+  describe "type parsing" do
+    config <<-CONFIG
+    filter {
+      noop {
+        add_tag => ["test"]
+      }
+    }
+    CONFIG
+
+    sample("type" => "noop") do
+      insist { subject["tags"] } == ["test"]
+    end
+  end
+
+  describe "tags parsing with one tag" do
+    config <<-CONFIG
+    filter {
+      noop {
+        add_tag => ["test"]
+      }
+    }
+    CONFIG
+
+    sample("type" => "noop") do
+      insist { subject["tags"] } == ["test"]
+    end
+
+    sample("type" => "noop", "tags" => ["t1", "t2"]) do
+      insist { subject["tags"] } == ["t1", "t2", "test"]
+    end
+  end
+
+  describe "tags parsing with multiple tags" do
+    config <<-CONFIG
+    filter {
+      noop {
+        add_tag => ["test"]
+      }
+    }
+    CONFIG
+
+    sample("type" => "noop") do
+      insist { subject["tags"] } == ["test"]
+    end
+
+    sample("type" => "noop", "tags" => ["t1"]) do
+      insist { subject["tags"] } == ["t1", "test"]
+    end
+
+    sample("type" => "noop", "tags" => ["t1", "t2"]) do
+      insist { subject["tags"] } == ["t1", "t2", "test"]
+    end
+
+    sample("type" => "noop", "tags" => ["t1", "t2", "t3"]) do
+      insist { subject["tags"] } == ["t1", "t2", "t3", "test"]
+    end
+  end
+
+  describe "remove_tag" do
+    config <<-CONFIG
+    filter {
+      noop {
+        remove_tag => ["t2", "t3"]
+      }
+    }
+    CONFIG
+
+    sample("type" => "noop", "tags" => ["t4"]) do
+      insist { subject["tags"] } == ["t4"]
+    end
+
+    sample("type" => "noop", "tags" => ["t1", "t2", "t3"]) do
+      insist { subject["tags"] } == ["t1"]
+    end
+
+    # also test from Json deserialized data to test the handling of native Java collections by JrJackson
+    # see https://github.com/elastic/logstash/issues/2261
+    sample(LogStash::Json.load("{\"type\":\"noop\", \"tags\":[\"t1\", \"t2\", \"t3\"]}")) do
+      insist { subject["tags"] } == ["t1"]
+    end
+
+    sample("type" => "noop", "tags" => ["t1", "t2"]) do
+      insist { subject["tags"] } == ["t1"]
+    end
+
+    # also test from Json deserialized data to test the handling of native Java collections by JrJackson
+    # see https://github.com/elastic/logstash/issues/2261
+    sample(LogStash::Json.load("{\"type\":\"noop\", \"tags\":[\"t1\", \"t2\"]}")) do
+      insist { subject["tags"] } == ["t1"]
+    end
+  end
+
+  describe "remove_tag with dynamic value" do
+    config <<-CONFIG
+    filter {
+      noop {
+        remove_tag => ["%{blackhole}"]
+      }
+    }
+    CONFIG
+
+    sample("type" => "noop", "tags" => ["t1", "goaway", "t3"], "blackhole" => "goaway") do
+      insist { subject["tags"] } == ["t1", "t3"]
+    end
+
+    # also test from Json deserialized data to test the handling of native Java collections by JrJackson
+    # see https://github.com/elastic/logstash/issues/2261
+    sample(LogStash::Json.load("{\"type\":\"noop\", \"tags\":[\"t1\", \"goaway\", \"t3\"], \"blackhole\":\"goaway\"}")) do
+      insist { subject["tags"] } == ["t1", "t3"]
+    end
+  end
+
+  describe "remove_field" do
+    config <<-CONFIG
+    filter {
+      noop {
+        remove_field => ["t2", "t3"]
+      }
+    }
+    CONFIG
+
+    sample("type" => "noop", "t4" => "four") do
+      insist { subject }.include?("t4")
+    end
+
+    sample("type" => "noop", "t1" => "one", "t2" => "two", "t3" => "three") do
+      insist { subject }.include?("t1")
+      reject { subject }.include?("t2")
+      reject { subject }.include?("t3")
+    end
+
+    sample("type" => "noop", "t1" => "one", "t2" => "two") do
+      insist { subject }.include?("t1")
+      reject { subject }.include?("t2")
+    end
+  end
+
+ describe "remove_field on deep objects" do
+    config <<-CONFIG
+    filter {
+      noop {
+        remove_field => ["[t1][t2]"]
+      }
+    }
+    CONFIG
+
+    sample("type" => "noop", "t1" => {"t2" => "two", "t3" => "three"}) do
+      insist { subject }.include?("t1")
+      reject { subject }.include?("[t1][t2]")
+      insist { subject }.include?("[t1][t3]")
+    end
+  end
+
+ describe "remove_field on array" do
+    config <<-CONFIG
+    filter {
+      noop {
+        remove_field => ["[t1][0]"]
+      }
+    }
+    CONFIG
+
+    sample("type" => "noop", "t1" => ["t2", "t3"]) do
+      insist { subject }.include?("t1")
+      insist { subject["[t1][0]"] } == "t3"
+    end
+  end
+
+  describe "remove_field with dynamic value in field name" do
+    config <<-CONFIG
+    filter {
+      noop {
+        remove_field => ["%{blackhole}"]
+      }
+    }
+    CONFIG
+
+    sample("type" => "noop", "blackhole" => "go", "go" => "away") do
+      insist { subject }.include?("blackhole")
+      reject { subject }.include?("go")
+    end
+  end
+end

data/spec/logstash/inputs/base_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+require "spec_helper"
+
+# use a dummy NOOP input to test Inputs::Base
+class LogStash::Inputs::NOOP < LogStash::Inputs::Base
+  config_name "noop"
+  milestone 2
+
+  def register; end
+
+end
+
+describe "LogStash::Inputs::Base#decorate" do
+  it "should add tag" do
+    input = LogStash::Inputs::NOOP.new("tags" => "value")
+    evt = LogStash::Event.new({"type" => "noop"})
+    input.instance_eval {decorate(evt)}
+    expect(evt["tags"]).to eq(["value"])
+  end
+
+  it "should add multiple tag" do
+    input = LogStash::Inputs::NOOP.new("tags" => ["value1","value2"])
+    evt = LogStash::Event.new({"type" => "noop"})
+    input.instance_eval {decorate(evt)}
+    expect(evt["tags"]).to eq(["value1","value2"])
+  end
+
+  it "should allow duplicates  tag" do
+    input = LogStash::Inputs::NOOP.new("tags" => ["value","value"])
+    evt = LogStash::Event.new({"type" => "noop"})
+    input.instance_eval {decorate(evt)}
+    expect(evt["tags"]).to eq(["value","value"])
+  end
+
+  it "should add tag with sprintf" do
+    input = LogStash::Inputs::NOOP.new("tags" => "%{type}")
+    evt = LogStash::Event.new({"type" => "noop"})
+    input.instance_eval {decorate(evt)}
+    expect(evt["tags"]).to eq(["noop"])
+  end
+
+  it "should add single field" do
+    input = LogStash::Inputs::NOOP.new("add_field" => {"field" => "value"})
+    evt = LogStash::Event.new({"type" => "noop"})
+    input.instance_eval {decorate(evt)}
+    expect(evt["field"]).to eq("value")
+  end
+
+  it "should add single field with sprintf" do
+    input = LogStash::Inputs::NOOP.new("add_field" => {"%{type}" => "%{type}"})
+    evt = LogStash::Event.new({"type" => "noop"})
+    input.instance_eval {decorate(evt)}
+    expect(evt["noop"]).to eq("noop")
+  end
+
+  it "should add multiple field" do
+    input = LogStash::Inputs::NOOP.new("add_field" => {"field" => ["value1", "value2"], "field2" => "value"})
+    evt = LogStash::Event.new({"type" => "noop"})
+    input.instance_eval {decorate(evt)}
+    expect(evt["field"]).to eq(["value1","value2"])
+    expect(evt["field2"]).to eq("value")
+  end
+end
+
+describe "LogStash::Inputs::Base#fix_streaming_codecs" do
+  it "should carry the charset setting along when switching" do
+    require "logstash/inputs/tcp"
+    require "logstash/codecs/plain"
+    plain = LogStash::Codecs::Plain.new("charset" => "CP1252")
+    tcp = LogStash::Inputs::Tcp.new("codec" => plain, "port" => 3333)
+    tcp.instance_eval { fix_streaming_codecs }
+    expect(tcp.codec.charset).to eq("CP1252")
+  end
+end

data/spec/logstash/java_integration_spec.rb

@@ -0,0 +1,304 @@
+# encoding: utf-8
+require "spec_helper"
+require "logstash/java_integration"
+
+describe "Java integration" do
+
+  context "type equivalence" do
+
+    # here we test for both is_a? and case/when usage of the Java types
+    # because these are the specific use-cases in our code and the expected
+    # behaviour.
+
+    context "Java::JavaUtil::ArrayList" do
+
+      it "should report to be a Ruby Array" do
+        expect(Java::JavaUtil::ArrayList.new.is_a?(Array)).to eq(true)
+      end
+
+      it "should be class equivalent to Ruby Array" do
+        expect do
+          case Java::JavaUtil::ArrayList.new
+          when Array
+            true
+          else
+            raise
+          end
+        end.not_to raise_error
+
+        expect(Array === Java::JavaUtil::ArrayList.new).to eq(true)
+      end
+    end
+
+    context "Java::JavaUtil::LinkedHashMap" do
+      it "should report to be a Ruby Hash" do
+        expect(Java::JavaUtil::LinkedHashMap.new.is_a?(Hash)).to eq(true)
+      end
+
+      it "should be class equivalent to Ruby Hash" do
+        expect do
+          case Java::JavaUtil::LinkedHashMap.new
+          when Hash
+            true
+          else
+            raise
+          end
+        end.not_to raise_error
+
+        expect(Hash === Java::JavaUtil::LinkedHashMap.new).to eq(true)
+      end
+    end
+  end
+
+  context "Java::JavaUtil::Map" do
+    # this is to test the Java 8 Map interface change for the merge method
+
+    let(:merger){{:a => 1, :b => 2}}
+    let(:mergee){{:b => 3, :c => 4}}
+
+    shared_examples "map merge" do
+      it "should support merging" do
+        expect(subject.merge(mergee)).to eq({:a => 1, :b => 3, :c => 4})
+      end
+
+      it "should return a new hash and not change original hash" do
+        expect{subject.merge(mergee)}.to_not change{subject}
+      end
+    end
+
+    context "with Java::JavaUtil::LinkedHashMap" do
+      it_behaves_like "map merge" do
+        subject{Java::JavaUtil::LinkedHashMap.new(merger)}
+      end
+    end
+
+    context "with Java::JavaUtil::HashMap" do
+      it_behaves_like "map merge" do
+        subject{Java::JavaUtil::HashMap.new(merger)}
+      end
+    end
+  end
+
+  context "Java::JavaUtil::Collection" do
+    subject{Java::JavaUtil::ArrayList.new(initial_array)}
+
+    context "when inspecting" do
+      let(:items) { [:a, {:b => :c}] }
+      subject { java.util.ArrayList.new(items) }
+
+      it "should include the contents of the Collection" do
+        expect(subject.inspect).to include(items.inspect)
+      end
+
+      it "should include the class name" do
+        expect(subject.inspect).to include("ArrayList")
+      end
+
+      it "should include the hash code of the collection" do
+        expect(subject.inspect).to include(subject.hashCode.to_s)
+      end
+    end
+
+    context "when deleting a unique instance" do
+      let(:initial_array) {["foo", "bar"]}
+
+      it "should return the deleted object" do
+        expect(subject.delete("foo")).to eq("foo")
+      end
+
+      it "should remove the object to delete" do
+        expect{subject.delete("foo")}.to change{subject.to_a}.from(initial_array).to(["bar"])
+      end
+    end
+
+    context "when deleting multiple instances" do
+      let(:initial_array) {["foo", "bar", "foo"]}
+
+      it "should return the last deleted object" do
+        expect(subject.delete("foo")).to eq("foo")
+      end
+
+      it "should remove all the objects to delete" do
+        expect{subject.delete("foo")}.to change{subject.to_a}.from(initial_array).to(["bar"])
+      end
+    end
+
+    context "when deleting non existing object" do
+      let(:initial_array) {["foo", "bar", "foo"]}
+
+      it "should return nil" do
+        expect(subject.delete("baz")).to be_nil
+      end
+
+      it "should not change the collection" do
+        expect{subject.delete("baz")}.to_not change{subject.to_a}
+      end
+
+      it "should yield to block when given" do
+        expect(subject.delete("baz"){"foobar"}).to eq("foobar")
+      end
+    end
+
+    context "when deleting on empty collection" do
+      let(:initial_array) {[]}
+
+      it "should return nil" do
+        expect(subject.delete("baz")).to be_nil
+      end
+
+      it "should not change the collection" do
+        expect{subject.delete("baz")}.to_not change{subject.to_a}
+      end
+    end
+
+    context "when intersecting with a Ruby Array" do
+
+      context "using string collection with duplicates and single result" do
+        let(:initial_array) {["foo", "bar", "foo"]}
+
+        it "should not change original collection" do
+          expect{subject & ["foo"]}.to_not change{subject.to_a}
+        end
+
+        it "should return a new array containing elements common to the two arrays, excluding any duplicate" do
+          expect((subject & ["foo"]).to_a).to eq(["foo"])
+        end
+      end
+
+      context "using string collection with duplicates and multiple results" do
+        let(:original) {["foo", "bar", "foo", "baz"]}
+        let(:target) {["baz", "foo"]}
+        let(:result) {["foo", "baz"]}
+
+        it "should return a new array containing elements common to the two arrays, excluding any duplicate and preserve order from the original array" do
+          # this is the Ruby contract
+          expect(original & target).to eq(result)
+
+          # this should work the same
+          expect((Java::JavaUtil::ArrayList.new(original) & target).to_a).to eq(result)
+        end
+      end
+
+      context "Ruby doc examples" do
+        it "should return a new array containing elements common to the two arrays, excluding any duplicate" do
+          expect(Java::JavaUtil::ArrayList.new(([1, 1, 3, 5]) & [1, 2, 3]).to_a).to eq([1, 3])
+          expect(Java::JavaUtil::ArrayList.new((['a', 'b', 'b', 'z']) & ['a', 'b', 'c']).to_a).to eq(['a', 'b'])
+        end
+      end
+    end
+
+    context "when unioning with a Ruby Array" do
+
+      context "using string collection with duplicates" do
+        let(:initial_array) {["foo", "bar", "foo"]}
+
+        it "should not change original collection" do
+          expect{subject | ["bar", "baz"]}.to_not change{subject.to_a}
+        end
+
+        it "should return a new array by joining excluding any duplicates and preserving the order from the original array" do
+          expect((subject | ["bar", "baz"]).to_a).to eq(["foo", "bar", "baz"])
+        end
+
+        it "should remove duplicates when joining empty array" do
+          expect((subject | []).to_a).to eq(["foo", "bar"])
+        end
+      end
+
+      context "Ruby doc examples" do
+        it "should return a new array containing elements common to the two arrays, excluding any duplicate" do
+          expect(Java::JavaUtil::ArrayList.new((["a", "b", "c"]) | ["c", "d", "a"]).to_a).to eq(["a", "b", "c", "d"])
+        end
+      end
+    end
+
+    context "when compacting" do
+      context "#compact with nils" do
+        let(:initial_array) { [1,2,3,nil,nil,6] }
+        it "should remove nil values from a copy" do
+          expect(subject.compact).to eq([1,2,3,6])
+          expect(subject).to eq([1,2,3,nil,nil,6])
+        end
+      end
+
+      context "#compact! with nils" do
+        let(:initial_array) { [1,2,3,nil,nil,6] }
+        it "should remove nil values" do
+          expect(subject.compact!).to eq([1,2,3,6])
+          expect(subject).to eq([1,2,3,6])
+        end
+
+        it "should return the original" do
+          expect(subject.compact!.object_id).to eq(subject.object_id)
+        end
+      end
+
+      context "#compact! without nils" do
+        let(:initial_array) { [1,2,3,6] }
+        it "should return nil" do
+          expect(subject.compact!).to be nil
+          expect(subject).to eq([1,2,3,6])
+        end
+      end
+    end
+  end
+
+  context "Enumerable implementation" do
+    context "Java Map interface should report key with nil value as included" do
+
+      it "should support include? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).include?("foo")).to eq(true)
+      end
+
+      it "should support has_key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).has_key?("foo")).to eq(true)
+      end
+
+      it "should support member? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).member?("foo")).to eq(true)
+      end
+
+      it "should support key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).key?("foo")).to eq(true)
+      end
+    end
+
+    context "Java Map interface should report key with a value as included" do
+
+      it "should support include? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).include?("foo")).to eq(true)
+      end
+
+      it "should support has_key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).has_key?("foo")).to eq(true)
+      end
+
+      it "should support member? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).member?("foo")).to eq(true)
+      end
+
+      it "should support key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).key?("foo")).to eq(true)
+      end
+    end
+
+    context "Java Map interface should report non existing key as not included" do
+
+      it "should support include? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1})).not_to include("bar")
+      end
+
+      it "should support has_key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).has_key?("bar")).to eq(false)
+      end
+
+      it "should support member? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).member?("bar")).to eq(false)
+      end
+
+      it "should support key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).key?("bar")).to eq(false)
+      end
+    end
+  end
+end