logstash-core 1.5.0.rc3.snapshot6-java → 1.5.0.rc4-java

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "logstash/devutils/rspec/spec_helper"

data/spec/util/accessors_spec.rb

@@ -0,0 +1,215 @@
+# encoding: utf-8
+require "spec_helper"
+require "logstash/util/accessors"
+
+describe LogStash::Util::Accessors, :if => true do
+
+  context "using simple field" do
+
+    it "should get value of word key" do
+      str = "hello"
+      data = { "hello" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data[str])
+    end
+
+    it "should get value of key with spaces" do
+      str = "hel lo"
+      data = { "hel lo" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data[str])
+    end
+
+    it "should get value of numeric key string" do
+      str = "1"
+      data = { "1" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data[str])
+    end
+
+    it "should handle delete" do
+      str = "simple"
+      data = { "simple" => "things" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to eq("things")
+      expect(data).to be_empty
+    end
+
+    it "should handle delete on non-existent field" do
+      str = "[foo][bar]"
+      data = { "hello" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to be_nil
+      expect(data).not_to be_empty
+      # assert no side effects
+      expect(accessors.get("foo")).to be_nil
+      expect(accessors.get("hello")).to eq("world")
+    end
+
+    it "should set string value" do
+      str = "simple"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "things")).to eq("things")
+      expect(data).to eq({ "simple" => "things" })
+    end
+
+    it "should set array value" do
+      str = "simple"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, ["foo", "bar"])).to eq(["foo", "bar"])
+      expect(data).to eq({ "simple" => ["foo", "bar"]})
+    end
+  end
+
+  context "using field path" do
+
+    it "should get shallow string value of word key" do
+      str = "[hello]"
+      data = { "hello" =>  "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq("world")
+    end
+
+    it "should get shallow string value of key with spaces" do
+      str = "[hel lo]"
+      data = { "hel lo" =>  "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq("world")
+    end
+
+    it "should get shallow string value of numeric key string" do
+      str = "[1]"
+      data = { "1" =>  "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq("world")
+    end
+
+    it "should get deep string value" do
+      str = "[hello][world]"
+      data = { "hello" => { "world" => "foo", "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data["hello"]["world"])
+    end
+
+    it "should return nil when getting a non-existant field (with no side-effects on original data)" do
+      str = "[hello][world]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to be_nil
+      expect(data).to  be_empty
+      expect(accessors.set(str, "foo")).to eq("foo")
+      expect(data).to eq({ "hello" => {"world" => "foo"} })
+    end
+
+    it "should handle delete" do
+      str = "[hello][world]"
+      data = { "hello" => { "world" => "foo", "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to eq("foo")
+
+      # Make sure the "world" key is removed.
+      expect(data["hello"]).to eq({ "bar" => "baz" })
+    end
+
+    it "should set shallow string value" do
+      str = "[hello]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "foo")).to eq("foo")
+      expect(data).to eq({ "hello" => "foo" })
+    end
+
+    it "should strict_set shallow string value" do
+      str = "[hello]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.strict_set(str, "foo")).to eq("foo")
+      expect(data).to eq({ "hello" => "foo"})
+    end
+
+    it "should set deep string value" do
+      str = "[hello][world]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "foo")).to eq("foo")
+      expect(data).to eq({ "hello" => { "world" => "foo" } })
+    end
+
+    it "should set deep array value" do
+      str = "[hello][world]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, ["foo", "bar"])).to eq(["foo", "bar"])
+      expect(data).to eq({ "hello" => { "world" => ["foo", "bar"] } })
+    end
+
+    it "should strict_set deep array value" do
+      str = "[hello][world]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.strict_set(str, ["foo", "bar"]) ).to eq(["foo", "bar"])
+      expect(data).to eq({ "hello" => { "world" => ["foo", "bar"] } })
+    end
+
+    it "should set element within array value" do
+      str = "[hello][0]"
+      data = {"hello" => ["foo", "bar"]}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "world") ).to eq("world")
+      expect(data).to eq({"hello" => ["world", "bar"]})
+    end
+
+    it "should retrieve array item" do
+      data = { "hello" => { "world" => ["a", "b"], "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get("[hello][world][0]")).to eq(data["hello"]["world"][0])
+      expect(accessors.get("[hello][world][1]")).to eq(data["hello"]["world"][1])
+    end
+
+    it "should retrieve array item containing hash" do
+      data = { "hello" => { "world" => [ { "a" => 123 }, { "b" => 345 } ], "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get("[hello][world][0][a]")).to eq(data["hello"]["world"][0]["a"])
+      expect(accessors.get("[hello][world][1][b]")).to eq(data["hello"]["world"][1]["b"])
+    end
+
+    it "should handle delete of array element" do
+      str = "[geocoords][0]"
+      data = { "geocoords" => [4, 2] }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to eq(4)
+      expect(data).to eq({ "geocoords" => [2] })
+    end  end
+
+  context "using invalid encoding" do
+    it "strinct_set should raise on non UTF-8 string encoding" do
+      str = "[hello]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect { accessors.strict_set(str, "foo".encode("US-ASCII")) }.to raise_error
+    end
+
+    it "strinct_set should raise on non UTF-8 string encoding in array" do
+      str = "[hello]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect { accessors.strict_set(str, ["foo", "bar".encode("US-ASCII")]) }.to raise_error
+    end
+
+    it "strinct_set should raise on invalid UTF-8 string encoding" do
+      str = "[hello]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect { accessors.strict_set(str, "foo \xED\xB9\x81\xC3") }.to raise_error
+    end
+
+    it "strinct_set should raise on invalid UTF-8 string encoding in array" do
+      str = "[hello]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect { accessors.strict_set(str, ["foo", "bar \xED\xB9\x81\xC3"]) }.to raise_error
+    end
+  end
+end

data/spec/util/charset_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+require "spec_helper"
+require "logstash/util/charset"
+
+describe LogStash::Util::Charset do
+  let(:logger) { double("logger") }
+
+  context "with valid UTF-8 source encoding" do
+    subject {LogStash::Util::Charset.new("UTF-8")}
+
+    it "should return untouched data" do
+      ["foobar", "κόσμε"].each do |data|
+        expect(data.encoding.name).to eq("UTF-8")
+        expect(subject.convert(data)).to eq(data)
+        expect(subject.convert(data).encoding.name).to eq("UTF-8")
+      end
+    end
+  end
+
+  context "with invalid UTF-8 source encoding" do
+    subject do
+      LogStash::Util::Charset.new("UTF-8").tap do |charset|
+        charset.logger = logger
+      end
+    end
+
+    it "should escape invalid sequences" do
+      ["foo \xED\xB9\x81\xC3", "bar \xAD"].each do |data|
+        expect(data.encoding.name).to eq("UTF-8")
+        expect(data.valid_encoding?).to eq(false)
+        expect(logger).to receive(:warn).exactly(2).times
+        #logger.should_receive(:warn).twice
+        expect(subject.convert(data)).to eq(data.inspect[1..-2])
+        expect(subject.convert(data).encoding.name).to eq("UTF-8")
+      end
+    end
+
+  end
+
+  context "with valid non UTF-8 source encoding" do
+    subject {LogStash::Util::Charset.new("ISO-8859-1")}
+
+    it "should encode to UTF-8" do
+      samples = [
+        ["foobar", "foobar"],
+        ["\xE0 Montr\xE9al", "à Montréal"],
+      ]
+      samples.map{|(a, b)| [a.force_encoding("ISO-8859-1"), b]}.each do |(a, b)|
+        expect(a.encoding.name).to eq("ISO-8859-1")
+        expect(b.encoding.name).to eq("UTF-8")
+        expect(a.valid_encoding?).to eq(true)
+        expect(subject.convert(a).encoding.name).to eq("UTF-8")
+        expect(subject.convert(a)).to eq(b)
+      end
+    end
+  end
+
+  context "with invalid non UTF-8 source encoding" do
+    subject {LogStash::Util::Charset.new("ASCII-8BIT")}
+
+    it "should encode to UTF-8 and replace invalid chars" do
+      samples = [
+        ["\xE0 Montr\xE9al", "� Montr�al"],
+        ["\xCE\xBA\xCF\x8C\xCF\x83\xCE\xBC\xCE\xB5", "����������"],
+      ]
+      samples.map{|(a, b)| [a.force_encoding("ASCII-8BIT"), b]}.each do |(a, b)|
+        expect(a.encoding.name).to eq("ASCII-8BIT")
+        expect(b.encoding.name).to eq("UTF-8")
+        expect(subject.convert(a).encoding.name).to eq("UTF-8")
+        expect(subject.convert(a)).to eq(b)
+      end
+    end
+  end
+end

data/spec/util/fieldeval_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+require "logstash/util/fieldreference"
+
+describe LogStash::Util::FieldReference, :if => true do
+
+  context "using simple accessor" do
+
+    it "should retrieve value" do
+      str = "hello"
+      m = eval(subject.compile(str))
+      data = { "hello" => "world" }
+      expect(m.call(data)).to eq(data[str])
+    end
+
+    it "should handle delete in block" do
+      str = "simple"
+      m = eval(subject.compile(str))
+      data = { "simple" => "things" }
+      m.call(data) { |obj, key| obj.delete(key) }
+      expect(data).to be_empty
+    end
+
+    it "should handle assignment in block" do
+      str = "simple"
+      m = eval(subject.compile(str))
+      data = {}
+      expect(m.call(data) { |obj, key| obj[key] = "things" }).to eq("things")
+      expect(data).to eq({ "simple" => "things" })
+    end
+
+    it "should handle assignment using set" do
+      str = "simple"
+      data = {}
+      expect(subject.set(str, "things", data)).to eq("things")
+      expect(data).to eq({ "simple" => "things" })
+    end
+  end
+
+  context "using accessor path" do
+
+    it "should retrieve shallow value" do
+      str = "[hello]"
+      m = eval(subject.compile(str))
+      data = { "hello" =>  "world" }
+      expect(m.call(data)).to eq("world")
+    end
+
+    it "should retrieve deep value" do
+      str = "[hello][world]"
+      m = eval(subject.compile(str))
+      data = { "hello" => { "world" => "foo", "bar" => "baz" } }
+      expect(m.call(data)).to eq(data["hello"]["world"])
+    end
+
+    it "should handle delete in block" do
+      str = "[hello][world]"
+      m = eval(subject.compile(str))
+      data = { "hello" => { "world" => "foo", "bar" => "baz" } }
+      m.call(data) { |obj, key| obj.delete(key) }
+
+      # Make sure the "world" key is removed.
+      expect(data["hello"]).to eq({ "bar" => "baz" })
+    end
+
+    it "should not handle assignment in block" do
+      str = "[hello][world]"
+      m = eval(subject.compile(str))
+      data = {}
+      expect(m.call(data) { |obj, key| obj[key] = "things" }).to be_nil
+      expect(data).to be_empty
+    end
+
+    it "should set shallow value" do
+      str = "[hello]"
+      data = {}
+      expect(subject.set(str, "foo", data)).to eq("foo")
+      expect(data).to eq({ "hello" => "foo" })
+    end
+
+    it "should set deep value" do
+      str = "[hello][world]"
+      data = {}
+      expect(subject.set(str, "foo", data)).to eq("foo")
+      expect(data).to eq({ "hello" => { "world" => "foo" } })
+    end
+
+    it "should retrieve array item" do
+      data = { "hello" => { "world" => ["a", "b"], "bar" => "baz" } }
+      m = eval(subject.compile("[hello][world][0]"))
+      expect(m.call(data)).to eq(data["hello"]["world"][0])
+
+      m = eval(subject.compile("[hello][world][1]"))
+      expect(m.call(data)).to eq(data["hello"]["world"][1])
+    end
+  end
+end

data/spec/util/gemfile_spec.rb

@@ -0,0 +1,212 @@
+# encoding: utf-8
+require "spec_helper"
+require "pluginmanager/gemfile"
+
+describe "logstash Gemfile Manager" do
+
+  context LogStash::Gemfile do
+
+    context "load" do
+
+      it "should load and return self" do
+        file = <<-END
+          source "https://rubygems.org"
+          gemspec :a => "a"
+          gem "test", "> 1.0", "< 2.0", :b => "b"
+        END
+
+        gemfile = LogStash::Gemfile.new(StringIO.new(file)).load
+        expect(gemfile).to be_an(LogStash::Gemfile)
+      end
+
+      it "should add sources" do
+        file = <<-END
+          source "a"
+          source "b"
+        END
+
+        gemfile = LogStash::Gemfile.new(StringIO.new(file)).load
+        expect(gemfile.gemset.sources.size).to eq(2)
+        expect(gemfile.gemset.sources).to eq(["a", "b"])
+      end
+
+      it "should add gemspec" do
+        file = <<-END
+          gemspec "foo"
+        END
+
+        gemfile = LogStash::Gemfile.new(StringIO.new(file)).load
+        expect(gemfile.gemset.gemspec).to eq("foo")
+      end
+
+      it "should raise on multiple gemspec" do
+        file = <<-END
+          gemspec "foo"
+          gemspec "boom"
+        END
+
+        expect{LogStash::Gemfile.new(StringIO.new(file)).load}.to raise_error(LogStash::GemfileError)
+      end
+
+      it "should add gems" do
+        file = <<-END
+          gem "foo"
+          gem "bar"
+        END
+
+        gemfile = LogStash::Gemfile.new(StringIO.new(file)).load
+        expect(gemfile.gemset.gems.size).to eq(2)
+        expect(gemfile.gemset.gems[0].name).to eq("foo")
+        expect(gemfile.gemset.gems[1].name).to eq("bar")
+      end
+
+      it "should raise on duplicate gem name" do
+        file = <<-END
+          gem "foo"
+          gem "foo"
+        END
+
+        expect{LogStash::Gemfile.new(StringIO.new(file)).load}.to raise_error(LogStash::GemfileError)
+      end
+
+      it "should add gems with only name" do
+        file = <<-END
+          gem "foo"
+        END
+
+        gemfile = LogStash::Gemfile.new(StringIO.new(file)).load
+
+        expect(gemfile.gemset.gems[0].name).to eq("foo")
+        expect(gemfile.gemset.gems[0].requirements.empty?).to eq(true)
+        expect(gemfile.gemset.gems[0].options.empty?).to eq(true)
+      end
+
+      it "should add gems with name and requirements" do
+        file = <<-END
+          gem "foo", "a"
+          gem "bar", "a", "b"
+        END
+
+        gemfile = LogStash::Gemfile.new(StringIO.new(file)).load
+
+        expect(gemfile.gemset.gems[0].name).to eq("foo")
+        expect(gemfile.gemset.gems[0].requirements).to eq(["a"])
+        expect(gemfile.gemset.gems[0].options.empty?).to eq(true)
+
+        expect(gemfile.gemset.gems[1].name).to eq("bar")
+        expect(gemfile.gemset.gems[1].requirements).to eq(["a", "b"])
+        expect(gemfile.gemset.gems[1].options.empty?).to eq(true)
+      end
+
+      it "should add gems with name and options" do
+        file = <<-END
+          gem "foo", :a => "a"
+          gem "bar", :a => "a", :b => "b"
+        END
+
+        gemfile = LogStash::Gemfile.new(StringIO.new(file)).load
+
+        expect(gemfile.gemset.gems[0].name).to eq("foo")
+        expect(gemfile.gemset.gems[0].requirements.empty?).to eq(true)
+        expect(gemfile.gemset.gems[0].options).to eq({:a => "a"})
+
+        expect(gemfile.gemset.gems[1].name).to eq("bar")
+        expect(gemfile.gemset.gems[1].requirements.empty?).to eq(true)
+        expect(gemfile.gemset.gems[1].options).to eq({:a => "a", :b => "b"})
+      end
+
+      it "should add gems with name, requirements and options" do
+        file = <<-END
+          gem "foo", "> 1.0", :b => "b"
+          gem "bar", "> 2.0", "< 3.0", :c => "c", :d => "d"
+        END
+
+        gemfile = LogStash::Gemfile.new(StringIO.new(file)).load
+        expect(gemfile.gemset.gems.size).to eq(2)
+
+        expect(gemfile.gemset.gems[0].name).to eq("foo")
+        expect(gemfile.gemset.gems[0].requirements).to eq(["> 1.0"])
+        expect(gemfile.gemset.gems[0].options).to eq({:b => "b"})
+
+        expect(gemfile.gemset.gems[1].name).to eq("bar")
+        expect(gemfile.gemset.gems[1].requirements).to eq(["> 2.0", "< 3.0"])
+        expect(gemfile.gemset.gems[1].options).to eq({:c => "c", :d => "d"})
+      end
+    end
+
+    describe "Locally installed gems" do
+      subject { LogStash::Gemfile.new(StringIO.new(file)).load.locally_installed_gems }
+
+      context "has gems defined with a path" do
+        let(:file) {
+          %Q[
+          source "https://rubygems.org"
+          gemspec :a => "a", "b" => 1
+          gem "foo", "> 1.0", :path => "/tmp/foo"
+          gem "bar", :path => "/tmp/bar"
+          gem "no-fun"
+          ]
+        }
+
+        it "returns the list of gems" do
+          expect(subject.collect(&:name)).to eq(["foo", "bar"])
+        end
+      end
+
+      context "no gems defined with a path" do
+        let(:file) {
+          %Q[
+          source "https://rubygems.org"
+          gemspec :a => "a", "b" => 1
+          gem "no-fun"
+          ]
+        }
+
+        it "return an empty list" do
+          expect(subject.size).to eq(0)
+        end
+      end
+
+      context "keep a backup of the original file" do
+
+      end
+    end
+
+    context "save" do
+      it "should save" do
+        file = <<-END
+          source "https://rubygems.org"
+          gemspec :a => "a", "b" => 1
+          gem "foo", "> 1.0", "< 2.0", :b => "b"
+          gem "bar"
+        END
+
+        io = StringIO.new(file)
+        gemfile = LogStash::Gemfile.new(io).load
+        gemfile.save
+        expect(file).to eq(
+          LogStash::Gemfile::HEADER + \
+          "source \"https://rubygems.org\"\n" + \
+          "gemspec :a => \"a\", \"b\" => 1\n" + \
+          "gem \"foo\", \"> 1.0\", \"< 2.0\", :b => \"b\"\n" + \
+          "gem \"bar\"\n"
+        )
+      end
+    end
+  end
+
+  context LogStash::DSL do
+    context "parse" do
+      it "should parse Gemfile content string" do
+        gemfile = <<-END
+          source "https://rubygems.org"
+          gemspec
+          gem "foo"
+        END
+
+        gemset = LogStash::DSL.parse(gemfile)
+        expect(gemset).to be_an(LogStash::Gemset)
+      end
+    end
+  end
+end