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

data/spec/inputs/base_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+require "spec_helper"
+
+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/lib/logstash/bundler_spec.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+require "spec_helper"
+require "bundler/cli"
+
+describe LogStash::Bundler do
+  context "capture_stdout" do
+    it "should capture stdout from block" do
+      original_stdout = $stdout
+      output, exception = LogStash::Bundler.capture_stdout do
+        expect($stdout).not_to eq(original_stdout)
+        puts("foobar")
+      end
+      expect($stdout).to eq(original_stdout)
+      expect(output).to eq("foobar\n")
+      expect(exception).to eq(nil)
+    end
+
+    it "should capture stdout and report exception from block" do
+      output, exception = LogStash::Bundler.capture_stdout do
+        puts("foobar")
+        raise(StandardError, "baz")
+      end
+      expect(output).to eq("foobar\n")
+      expect(exception).to be_a(StandardError)
+      expect(exception.message).to eq("baz")
+    end
+  end
+
+  context 'when invoking bundler' do
+    original_stderr = $stderr
+
+    subject { LogStash::Bundler.invoke!(options) }
+    # by default we want to fail fast on the test
+    let(:options) { { :install => true, :max_tries => 0, :without => [:development]} }
+    let(:bundler_args) { LogStash::Bundler.bundler_arguments(options) }
+
+    before do
+      $stderr = StringIO.new
+
+      expect(::Bundler).to receive(:reset!).at_least(1)
+    end
+
+    after do
+      expect(::Bundler.settings[:path]).to eq(LogStash::Environment::BUNDLE_DIR)
+      expect(::Bundler.settings[:gemfile]).to eq(LogStash::Environment::GEMFILE_PATH)
+      expect(::Bundler.settings[:without]).to eq(options.fetch(:without, []).join(':'))
+
+      expect(ENV['GEM_PATH']).to eq(LogStash::Environment.logstash_gem_home)
+
+      $stderr = original_stderr
+    end
+
+    it 'should call Bundler::CLI.start with the correct arguments' do
+      expect(::Bundler::CLI).to receive(:start).with(bundler_args)
+      LogStash::Bundler.invoke!(options)
+    end
+
+    context 'abort with an exception' do
+      it 'gem conflict' do
+        allow(::Bundler::CLI).to receive(:start).with(bundler_args) { raise ::Bundler::VersionConflict.new('conflict') }
+        expect { subject }.to raise_error(::Bundler::VersionConflict)
+      end
+
+      it 'gem is not found' do
+        allow(::Bundler::CLI).to receive(:start).with(bundler_args) { raise ::Bundler::GemNotFound.new('conflict') }
+        expect { subject }.to raise_error(::Bundler::GemNotFound)
+      end
+
+      it 'on max retries' do
+        options.merge!({ :max_tries => 2 })
+        expect(::Bundler::CLI).to receive(:start).with(bundler_args).at_most(options[:max_tries] + 1) { raise RuntimeError }
+        expect { subject }.to raise_error(RuntimeError)
+      end
+    end
+  end
+
+  context 'when generating bundler arguments' do
+    subject { LogStash::Bundler.bundler_arguments(options) }
+    let(:options) { {} }
+
+    context 'when installing' do
+      let(:options) { { :install => true } }
+
+      it 'should call bundler install' do
+        expect(subject).to include('install')
+      end
+
+      context 'with the cleaning option' do
+        it 'should add the --clean arguments' do
+          options.merge!(:clean => true)
+          expect(subject).to include('install','--clean')
+        end
+      end
+    end
+
+    context "when updating" do
+      let(:options) { { :update => 'logstash-input-stdin' } }
+
+      context 'with a specific plugin' do
+        it 'should call `bundle update plugin-name`' do
+          expect(subject).to include('update', 'logstash-input-stdin')
+        end
+      end
+
+      context 'with the cleaning option' do
+        it 'should ignore the clean option' do
+          options.merge!(:clean => true)
+          expect(subject).not_to include('--clean')
+        end
+      end
+    end
+
+    context "when only specifying clean" do
+      let(:options) { { :clean => true } }
+      it 'should call the `bundle clean`' do
+        expect(subject).to include('clean')
+      end
+    end
+  end
+end

data/spec/lib/logstash/java_integration_spec.rb

@@ -0,0 +1,257 @@
+# 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 be_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 be_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 be_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 be_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 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
+  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 be_true
+      end
+
+      it "should support has_key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).has_key?("foo")).to be_true
+      end
+
+      it "should support member? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).member?("foo")).to be_true
+      end
+
+      it "should support key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => nil}).key?("foo")).to be_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 be_true
+      end
+
+      it "should support has_key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).has_key?("foo")).to be_true
+      end
+
+      it "should support member? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).member?("foo")).to be_true
+      end
+
+      it "should support key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).key?("foo")).to be_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}).include?("bar")).to be_false
+      end
+
+      it "should support has_key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).has_key?("bar")).to be_false
+      end
+
+      it "should support member? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).member?("bar")).to be_false
+      end
+
+      it "should support key? method" do
+        expect(Java::JavaUtil::LinkedHashMap.new({"foo" => 1}).key?("bar")).to be_false
+      end
+    end
+  end
+end

data/spec/logstash/agent_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe LogStash::Agent do
+  subject { LogStash::Agent.new('') }
+  let(:dummy_config) { 'input {}' }
+
+  context "when loading the configuration" do
+    context "when local" do
+      before { expect(subject).to receive(:local_config).with(path) }
+
+      context "unix" do
+        let(:path) { './test.conf' }
+        it 'works with relative path' do
+          subject.load_config(path)
+        end
+      end
+
+      context "windows" do
+        let(:path) { '.\test.conf' }
+        it 'work with relative windows path' do
+          subject.load_config(path)
+        end
+      end
+    end
+    
+    context "when remote" do
+      context 'supported scheme' do
+        let(:path) { "http://test.local/superconfig.conf" }
+
+        before { expect(Net::HTTP).to receive(:get) { dummy_config } }
+        it 'works with http' do
+          expect(subject.load_config(path)).to eq("#{dummy_config}\n")
+        end
+      end
+    end
+  end
+end

data/spec/outputs/base_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+require "spec_helper"
+
+# use a dummy NOOP output to test Outputs::Base
+class LogStash::Outputs::NOOP < LogStash::Outputs::Base
+  config_name "noop"
+  milestone 2
+
+  config :dummy_option, :validate => :string
+
+  def register; end
+
+  def receive(event)
+    return output?(event)
+  end
+end
+
+describe "LogStash::Outputs::Base#worker_setup" do
+  it "should create workers using original parameters except workers = 1" do
+    params = { "dummy_option" => "potatoes", "codec" => "json", "workers" => 2 }
+    worker_params = params.dup; worker_params["workers"] = 1
+    output = LogStash::Outputs::NOOP.new(params.dup)
+    expect(LogStash::Outputs::NOOP).to receive(:new).twice.with(worker_params).and_call_original
+    output.worker_setup
+  end
+end
+
+describe "LogStash::Outputs::Base#output?" do
+  it "should filter by type" do
+    output = LogStash::Outputs::NOOP.new("type" => "noop")
+    expect(output.receive(LogStash::Event.new({"type" => "noop"}))).to eq(true)
+    expect(output.receive(LogStash::Event.new({"type" => "not_noop"}))).to eq(false)
+  end
+  
+  it "should filter by tags" do
+    output = LogStash::Outputs::NOOP.new("tags" => ["value", "value2"])
+    expect(output.receive(LogStash::Event.new({"tags" => ["value","value2"]}))).to eq(true)
+    expect(output.receive(LogStash::Event.new({"tags" => ["notvalue"]}))).to eq(false)
+    expect(output.receive(LogStash::Event.new({"tags" => ["value"]}))).to eq(false)
+  end
+
+  it "should exclude by tags" do
+    output = LogStash::Outputs::NOOP.new("exclude_tags" => ["value"])
+    expect(output.receive(LogStash::Event.new({"tags" => ["value"]}))).to eq(false)
+    expect(output.receive(LogStash::Event.new({"tags" => ["notvalue"]}))).to eq(true)
+  end
+end