logstash-core 2.1.3-java → 2.2.0-java

data/spec/spec_helper.rb

@@ -1,11 +0,0 @@
-# encoding: utf-8
-require_relative 'coverage_helper'
-# In order to archive an expected coverage analysis we need to eager load
-# all logstash code base, otherwise it will not get a good analysis.
-CoverageHelper.eager_load if ENV['COVERAGE']
-
-require "logstash/devutils/rspec/spec_helper"
-
-def installed_plugins
-  Gem::Specification.find_all.select { |spec| spec.metadata["logstash_plugin"] }.map { |plugin| plugin.name }
-end

data/spec/util/accessors_spec.rb

@@ -1,170 +0,0 @@
-# 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 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 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
-end

data/spec/util/compress_spec.rb

@@ -1,121 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-require 'ostruct'
-require "bootstrap/util/compress"
-
-describe LogStash::Util::Zip do
-
-  subject { Class.new { extend LogStash::Util::Zip } }
-
-  context "#extraction" do
-
-    let(:source) { File.join(File.expand_path("."), "source_file.zip") }
-    let(:target) { File.expand_path("target_dir") }
-
-    it "raise an exception if the target dir exist" do
-      allow(File).to receive(:exist?).with(target).and_return(true)
-      expect { subject.extract(source, target) }.to raise_error
-    end
-
-    let(:zip_file) do
-      [ "foo", "bar", "zoo" ].inject([]) do |acc, name|
-        acc << OpenStruct.new(:name => name)
-        acc
-      end
-    end
-
-    it "extract the list of entries from a zip file" do
-      allow(Zip::File).to receive(:open).with(source).and_yield(zip_file)
-      expect(FileUtils).to receive(:mkdir_p).exactly(3).times
-      expect(zip_file).to receive(:extract).exactly(3).times
-      subject.extract(source, target)
-    end
-  end
-
-  context "#compression" do
-
-    let(:target) { File.join(File.expand_path("."), "target_file.zip") }
-    let(:source) { File.expand_path("source_dir") }
-
-    it "raise an exception if the target file exist" do
-      allow(File).to receive(:exist?).with(target).and_return(true)
-      expect { subject.compress(source, target) }.to raise_error
-    end
-
-    let(:dir_files) do
-      [ "foo", "bar", "zoo" ]
-    end
-
-    let(:zip_file) { Class.new }
-
-    it "add a dir to a zip file" do
-      allow(Zip::File).to receive(:open).with(target, ::Zip::File::CREATE).and_yield(zip_file)
-      allow(Dir).to receive(:glob).and_return(dir_files)
-      expect(zip_file).to receive(:add).exactly(3).times
-      subject.compress(source, target)
-    end
-  end
-end
-
-describe LogStash::Util::Tar do
-
-  subject { Class.new { extend LogStash::Util::Tar } }
-
-  context "#extraction" do
-
-    let(:source) { File.join(File.expand_path("."), "source_file.tar.gz") }
-    let(:target) { File.expand_path("target_dir") }
-
-    it "raise an exception if the target dir exist" do
-      allow(File).to receive(:exist?).with(target).and_return(true)
-      expect { subject.extract(source, target) }.to raise_error
-    end
-
-    let(:gzip_file) { Class.new }
-
-    let(:tar_file) do
-      [ "foo", "bar", "zoo" ].inject([]) do |acc, name|
-        acc << OpenStruct.new(:full_name => name)
-        acc
-      end
-    end
-
-    it "extract the list of entries from a tar.gz file" do
-      allow(Zlib::GzipReader).to receive(:open).with(source).and_yield(gzip_file)
-      allow(Gem::Package::TarReader).to receive(:new).with(gzip_file).and_yield(tar_file)
-
-      expect(FileUtils).to receive(:mkdir).with(target)
-      expect(File).to receive(:open).exactly(3).times
-      subject.extract(source, target)
-    end
-  end
-
-  context "#compression" do
-
-    let(:target) { File.join(File.expand_path("."), "target_file.tar.gz") }
-    let(:source) { File.expand_path("source_dir") }
-
-    it "raise an exception if the target file exist" do
-      allow(File).to receive(:exist?).with(target).and_return(true)
-      expect { subject.compress(source, target) }.to raise_error
-    end
-
-    let(:dir_files) do
-      [ "foo", "bar", "zoo" ]
-    end
-
-    let(:tar_file) { Class.new }
-    let(:tar)      { Class.new }
-
-    it "add a dir to a tgz file" do
-      allow(Stud::Temporary).to receive(:file).and_yield(tar_file)
-      allow(Gem::Package::TarWriter).to receive(:new).with(tar_file).and_yield(tar)
-      allow(Dir).to receive(:glob).and_return(dir_files)
-      expect(File).to receive(:stat).exactly(3).times.and_return(OpenStruct.new(:mode => "rw"))
-      expect(tar).to receive(:add_file).exactly(3).times
-      expect(tar_file).to receive(:rewind)
-      expect(subject).to receive(:gzip).with(target, tar_file)
-      subject.compress(source, target)
-    end
-  end
-end

data/spec/util/gemfile_spec.rb

@@ -1,212 +0,0 @@
-# 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