logstash-filter-zabbix 0.1.1

data/vendor/bundle/jruby/1.9/gems/logstash-core-2.4.1-java/spec/logstash/config/mixin_spec.rb

@@ -0,0 +1,395 @@
+# encoding: utf-8
+require "spec_helper"
+require "logstash/config/mixin"
+
+describe LogStash::Config::Mixin do
+  context "when validating :bytes successfully" do
+    subject do
+      local_num_bytes = num_bytes # needs to be locally scoped :(
+      Class.new(LogStash::Filters::Base) do
+        include LogStash::Config::Mixin
+        config_name "test"
+        milestone 1
+        config :size_bytes, :validate => :bytes
+        config :size_default, :validate => :bytes, :default => "#{local_num_bytes}"
+        config :size_upcase, :validate => :bytes
+        config :size_downcase, :validate => :bytes
+        config :size_space, :validate => :bytes
+      end.new({
+        "size_bytes" => "#{local_num_bytes}",
+        "size_upcase" => "#{local_num_bytes}KiB".upcase,
+        "size_downcase" => "#{local_num_bytes}KiB".downcase,
+        "size_space" => "#{local_num_bytes} KiB"
+      })
+    end
+
+    let!(:num_bytes) { rand(1000) }
+    let!(:num_kbytes) { num_bytes * 1024 }
+
+    it "should validate :bytes successfully with no units" do
+      expect(subject.size_bytes).to eq(num_bytes)
+    end
+
+    it "should allow setting valid default" do
+      expect(subject.size_default).to eq(num_bytes)
+    end
+
+    it "should be case-insensitive when parsing units" do
+      expect(subject.size_upcase).to eq(num_kbytes)
+      expect(subject.size_downcase).to eq(num_kbytes)
+    end
+
+    it "should accept one space between num_bytes and unit suffix" do
+      expect(subject.size_space).to eq(num_kbytes)
+    end
+  end
+
+  context "when raising configuration errors while validating" do
+    it "should raise configuration error when provided with invalid units" do
+      expect {
+        Class.new(LogStash::Filters::Base) do
+          include LogStash::Config::Mixin
+          config_name "test"
+          milestone 1
+          config :size_file, :validate => :bytes
+        end.new({"size_file" => "10 yolobytes"})
+      }.to raise_error(LogStash::ConfigurationError)
+    end
+
+    it "should raise configuration error when provided with too many spaces" do
+      expect {
+        Class.new(LogStash::Filters::Base) do
+          include LogStash::Config::Mixin
+          config_name "test"
+          milestone 1
+          config :size_file, :validate => :bytes
+        end.new({"size_file" => "10  kib"})
+      }.to raise_error(LogStash::ConfigurationError)
+    end
+  end
+
+  context "when validating lists of items" do
+    let(:klass) do
+      Class.new(LogStash::Filters::Base)  do
+        config_name "multiuri"
+        config :uris, :validate => :uri, :list => true
+        config :strings, :validate => :string, :list => true
+        config :required_strings, :validate => :string, :list => true, :required => true
+      end
+    end
+
+    let(:uris) { ["http://example.net/1", "http://example.net/2"] }
+    let(:safe_uris) { uris.map {|str| ::LogStash::Util::SafeURI.new(str) } }
+    let(:strings) { ["I am a", "modern major general"] }
+    let(:required_strings) { ["required", "strings"] }
+
+    subject { klass.new("uris" => uris, "strings" => strings, "required_strings" => required_strings) }
+
+    it "a URI list should return an array of URIs" do
+      expect(subject.uris).to match_array(safe_uris)
+    end
+
+    it "a string list should return an array of strings" do
+      expect(subject.strings).to match_array(strings)
+    end
+
+    context "with a scalar value" do
+      let(:strings) { "foo" }
+
+      it "should return the scalar value as a single element array" do
+        expect(subject.strings).to match_array([strings])
+      end
+    end
+
+    context "with an empty list" do
+      let(:strings) { [] }
+
+      it "should return nil" do
+        expect(subject.strings).to be_nil
+      end
+    end
+
+    describe "with required => true" do
+      context "and a single element" do
+        let(:required_strings) { ["foo"] }
+
+        it "should return the single value" do
+          expect(subject.required_strings).to eql(required_strings)
+        end
+      end
+
+      context "with an empty list" do
+        let (:required_strings) { [] }
+
+        it "should raise a configuration error" do
+          expect { subject.required_strings }.to raise_error(LogStash::ConfigurationError)
+        end        
+      end
+
+      context "with no value specified" do
+        let (:required_strings) { nil }
+
+        it "should raise a configuration error" do
+          expect { subject.required_strings }.to raise_error(LogStash::ConfigurationError)
+        end
+      end          
+    end
+  end
+
+  context "when validating :password" do
+    let(:klass) do
+      Class.new(LogStash::Filters::Base)  do
+        config_name "fake"
+        config :password, :validate => :password
+      end
+    end
+
+    let(:secret) { "fancy pants" }
+    subject { klass.new("password" => secret) }
+
+    it "should be a Password object" do
+      expect(subject.password).to(be_a(LogStash::Util::Password))
+    end
+
+    it "should make password values hidden" do
+      expect(subject.password.to_s).to(be == "<password>")
+      expect(subject.password.inspect).to(be == "<password>")
+    end
+
+    it "should show password values via #value" do
+      expect(subject.password.value).to(be == secret)
+    end
+
+    it "should correctly copy password types" do
+      clone = subject.class.new(subject.params)
+      expect(clone.password.value).to(be == secret)
+    end
+
+    it "should obfuscate original_params" do
+      expect(subject.original_params['password']).to(be_a(LogStash::Util::Password))
+    end
+  end
+
+  context "when validating :uri" do
+    let(:klass) do
+      Class.new(LogStash::Filters::Base)  do
+        config_name "fakeuri"
+        config :uri, :validate => :uri
+      end
+    end
+
+    shared_examples("safe URI") do |options|
+      options ||= {}
+      
+      subject { klass.new("uri" => uri_str) }
+
+      it "should be a SafeURI object" do
+        expect(subject.uri).to(be_a(LogStash::Util::SafeURI))
+      end
+
+      it "should correctly copy URI types" do
+        clone = subject.class.new(subject.params)
+        expect(clone.uri.to_s).to eql(uri_hidden)
+      end
+
+      it "should make the real URI object availale under #uri" do
+        expect(subject.uri.uri).to be_a(::URI)
+      end
+
+      it "should obfuscate original_params" do
+        expect(subject.original_params['uri']).to(be_a(LogStash::Util::SafeURI))
+      end
+
+      if !options[:exclude_password_specs]
+        describe "passwords" do
+          it "should make password values hidden with #to_s" do
+            expect(subject.uri.to_s).to eql(uri_hidden)
+          end
+
+          it "should make password values hidden with #inspect" do
+            expect(subject.uri.inspect).to eql(uri_hidden)
+          end
+        end
+      end
+
+      context "attributes" do
+        [:scheme, :user, :password, :hostname, :path].each do |attr|
+          it "should make #{attr} available" do
+            expect(subject.uri.send(attr)).to eql(self.send(attr))
+          end
+        end
+      end
+    end
+
+    context "with a host:port combination" do
+      let(:scheme) { nil }
+      let(:user) { nil }
+      let(:password) { nil }
+      let(:hostname) { "myhostname" }
+      let(:port) { 1234 }
+      let(:path) { "" }
+      let(:uri_str) { "#{hostname}:#{port}" }
+      let(:uri_hidden) { "//#{hostname}:#{port}" }
+
+      include_examples("safe URI", :exclude_password_specs => true)
+    end
+
+    context "with a username / password" do
+      let(:scheme) { "myscheme" }
+      let(:user) { "myuser" }
+      let(:password) { "fancypants" }
+      let(:hostname) { "myhostname" }
+      let(:path) { "/my/path" }
+      let(:uri_str) { "#{scheme}://#{user}:#{password}@#{hostname}#{path}" }
+      let(:uri_hidden) { "#{scheme}://#{user}:#{LogStash::Util::SafeURI::PASS_PLACEHOLDER}@#{hostname}#{path}" }
+
+      include_examples("safe URI")
+    end
+
+    context "without a username / password" do
+      let(:scheme) { "myscheme" }
+      let(:user) { nil }
+      let(:password) { nil }
+      let(:hostname) { "myhostname" }
+      let(:path) { "/my/path" }
+      let(:uri_str) { "#{scheme}://#{hostname}#{path}" }
+      let(:uri_hidden) { "#{scheme}://#{hostname}#{path}" }
+
+      include_examples("safe URI")
+    end
+  end
+
+  describe "obsolete settings" do
+    let(:plugin_class) do
+      Class.new(LogStash::Inputs::Base) do
+        include LogStash::Config::Mixin
+        config_name "example"
+        config :foo, :validate => :string, :obsolete => "This feature was removed."
+      end
+    end
+
+    context "when using an obsolete setting" do
+      it "should cause a configuration error" do
+        expect {
+          plugin_class.new("foo" => "hello")
+        }.to raise_error(LogStash::ConfigurationError)
+      end
+    end
+
+    context "when using an obsolete settings from the parent class" do
+      it "should cause a configuration error" do
+        expect {
+          plugin_class.new("debug" => true)
+        }.to raise_error(LogStash::ConfigurationError)
+      end
+    end
+
+    context "when not using an obsolete setting" do
+      it "should not cause a configuration error" do
+        expect {
+          plugin_class.new({})
+        }.not_to raise_error
+      end
+    end
+  end
+
+  context "#params" do
+    let(:plugin_class) do
+      Class.new(LogStash::Filters::Base)  do
+        config_name "fake"
+        config :password, :validate => :password
+        config :bad, :validate => :string, :default => "my default", :obsolete => "not here"
+      end
+    end
+
+    subject { plugin_class.new({ "password" => "secret" }) }
+
+    it "should not return the obsolete options" do
+      expect(subject.params).not_to include("bad")
+    end
+
+    it "should include any other params" do
+      expect(subject.params).to include("password")
+    end
+  end
+
+  context "environment variable evaluation" do
+    let(:plugin_class) do
+      Class.new(LogStash::Filters::Base)  do
+        config_name "one_plugin"
+        config :oneString, :validate => :string
+        config :oneBoolean, :validate => :boolean
+        config :oneNumber, :validate => :number
+        config :oneArray, :validate => :array
+        config :oneHash, :validate => :hash
+
+        def initialize(params)
+          super(params.merge(LogStash::Config::Mixin::ALLOW_ENV_FLAG => true))
+        end
+      end
+    end
+
+    context "when an environment variable is not set" do
+      context "and no default is given" do
+        before do
+          # Canary. Just in case somehow this is set.
+          expect(ENV["NoSuchVariable"]).to be_nil
+        end
+
+        it "should raise a configuration error" do
+          expect do
+            plugin_class.new("oneString" => "${NoSuchVariable}")
+          end.to raise_error(LogStash::ConfigurationError)
+        end
+      end
+
+      context "and a default is given" do
+        subject do
+          plugin_class.new(
+            "oneString" => "${notExistingVar:foo}",
+            "oneBoolean" => "${notExistingVar:true}",
+            "oneArray" => [ "first array value", "${notExistingVar:foo}", "${notExistingVar:}", "${notExistingVar: }", "${notExistingVar:foo bar}" ],
+            "oneHash" => { "key" => "${notExistingVar:foo}" }
+          )
+        end
+
+        it "should use the default" do
+          expect(subject.oneString).to(be == "foo")
+          expect(subject.oneBoolean).to be_truthy
+          expect(subject.oneArray).to(be == ["first array value", "foo", "", " ", "foo bar"])
+          expect(subject.oneHash).to(be == { "key" => "foo" })
+        end
+      end
+    end
+
+    context "when an environment variable is set" do
+      before do
+        ENV["FunString"] = "fancy"
+        ENV["FunBool"] = "true"
+      end
+
+      after do
+        ENV.delete("FunString")
+        ENV.delete("FunBool")
+      end
+
+      subject do
+        plugin_class.new(
+          "oneString" => "${FunString:foo}",
+          "oneBoolean" => "${FunBool:false}",
+          "oneArray" => [ "first array value", "${FunString:foo}" ],
+          "oneHash" => { "key1" => "${FunString:foo}", "key2" => "${FunString} is ${FunBool}", "key3" => "${FunBool:false} or ${funbool:false}" }
+        )
+      end
+
+      it "should use the value in the variable" do
+        expect(subject.oneString).to(be == "fancy")
+        expect(subject.oneBoolean).to(be_truthy)
+        expect(subject.oneArray).to(be == [ "first array value", "fancy" ])
+        expect(subject.oneHash).to(be == { "key1" => "fancy", "key2" => "fancy is true", "key3" => "true or false" })
+      end
+
+    end
+  end
+
+end

data/vendor/bundle/jruby/1.9/gems/logstash-core-2.4.1-java/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