logstash-core 2.2.4.snapshot1

data/spec/logstash/agent_spec.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+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
+
+  context "--pluginpath" do
+    let(:single_path) { "/some/path" }
+    let(:multiple_paths) { ["/some/path1", "/some/path2"] }
+
+    it "should add single valid dir path to the environment" do
+      expect(File).to receive(:directory?).and_return(true)
+      expect(LogStash::Environment).to receive(:add_plugin_path).with(single_path)
+      subject.configure_plugin_paths(single_path)
+    end
+
+    it "should fail with single invalid dir path" do
+      expect(File).to receive(:directory?).and_return(false)
+      expect(LogStash::Environment).not_to receive(:add_plugin_path)
+      expect{subject.configure_plugin_paths(single_path)}.to raise_error(LogStash::ConfigurationError)
+    end
+
+    it "should add multiple valid dir path to the environment" do
+      expect(File).to receive(:directory?).exactly(multiple_paths.size).times.and_return(true)
+      multiple_paths.each{|path| expect(LogStash::Environment).to receive(:add_plugin_path).with(path)}
+      subject.configure_plugin_paths(multiple_paths)
+    end
+  end
+
+  describe "debug_config" do
+    let(:pipeline_string) { "input {} output {}" }
+    let(:pipeline) { double("pipeline") }
+
+    before(:each) do
+      allow(pipeline).to receive(:run)
+    end
+    it "should set 'debug_config' to false by default" do
+      expect(LogStash::Pipeline).to receive(:new).
+        with(anything,hash_including(:debug_config => false)).
+        and_return(pipeline)
+      args = ["--debug", "-e", pipeline_string]
+      subject.run(args)
+    end
+
+    it "should allow overriding debug_config" do
+      expect(LogStash::Pipeline).to receive(:new).
+        with(anything, hash_including(:debug_config => true))
+        .and_return(pipeline)
+      args = ["--debug", "--debug-config",  "-e", pipeline_string]
+      subject.run(args)
+    end
+  end
+end

data/spec/logstash/config/config_ast_spec.rb

@@ -0,0 +1,146 @@
+# encoding: utf-8
+# config syntax tests
+#
+require "spec_helper"
+require "logstash/config/grammar"
+require "logstash/config/config_ast"
+
+describe LogStashConfigParser do
+  context '#parse' do
+    context "valid configuration" do
+      it "should permit single-quoted attribute names" do
+        parser = LogStashConfigParser.new
+        config = parser.parse(%q(
+          input {
+            example {
+              'foo' => 'bar'
+              test => { 'bar' => 'baz' }
+            }
+          }
+          ))
+
+        expect(config).not_to be_nil
+      end
+
+      it "should permit empty plugin sections" do
+        parser = LogStashConfigParser.new
+        config = parser.parse(%q(
+          filter {
+          }
+          ))
+
+        expect(config).not_to be_nil
+      end
+
+      it 'permits hash to contains array' do
+        parser = LogStashConfigParser.new
+        config = parser.parse(%q(
+          input{
+            example {
+              match => {
+                "message"=> ["pattern1", "pattern2", "pattern3"]
+              }
+            }
+          }))
+        expect(config).not_to be_nil
+      end
+    end
+  end
+
+  context "#compile" do
+    context "if with multiline conditionals" do
+      let(:config) { <<-CONFIG }
+        filter {
+          if [something]
+             or [anotherthing]
+             or [onemorething] {
+          }
+        }
+      CONFIG
+      subject { LogStashConfigParser.new }
+         
+      it "should compile successfully" do
+        result = subject.parse(config)
+        expect(result).not_to(be_nil)
+        expect { eval(result.compile) }.not_to(raise_error)
+      end
+    end
+
+    context "elsif with multiline conditionals" do
+      let(:config) { <<-CONFIG }
+        filter {
+          if [notathing] {
+          } else if [something]
+                or [anotherthing]
+                or [onemorething] {
+          }
+        }
+      CONFIG
+      subject { LogStashConfigParser.new }
+         
+      it "should compile successfully" do
+        result = subject.parse(config)
+        expect(result).not_to(be_nil)
+        expect { eval(result.compile) }.not_to(raise_error)
+      end
+    end
+
+
+    context "invalid configuration" do
+      it "rejects duplicate hash key" do
+        parser = LogStashConfigParser.new
+        config = parser.parse(%q(
+          input {
+            example {
+              match => {
+                "message"=> "pattern1"
+                "message"=> "pattern2"
+                "message"=> "pattern3"
+              }
+            }
+          }
+        ))
+
+        expect { config.compile }.to raise_error(LogStash::ConfigurationError, /Duplicate keys found in your configuration: \["message"\]/)
+      end
+
+      it "rejects duplicate keys in nested hash" do
+        parser = LogStashConfigParser.new
+        config = parser.parse(%q(
+          input {
+            example {
+              match => {
+                "message"=> "pattern1"
+                "more" => {
+                  "cool" => true
+                  "cool" => true
+                }
+              }
+            }
+          }
+        ))
+
+        expect { config.compile }.to raise_error(LogStash::ConfigurationError, /Duplicate keys found in your configuration: \["cool"\]/)
+      end
+
+      it "rejects a key with multiple double quotes" do
+        parser = LogStashConfigParser.new
+        config = parser.parse(%q(
+          input {
+            example {
+              match => {
+                "message"=> "pattern1"
+                ""more"" => {
+                  "cool" => true
+                  "cool" => true
+                }
+              }
+            }
+          }
+        ))
+
+        expect(config).to be_nil
+      end
+    end
+  end
+end

data/spec/logstash/config/cpu_core_strategy_spec.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+require "spec_helper"
+require "logstash/config/cpu_core_strategy"
+
+describe LogStash::Config::CpuCoreStrategy do
+
+  before do
+    allow(LogStash::Config::Defaults).to receive(:cpu_cores).and_return(cores)
+  end
+
+  context 'when the machine has 6 cores' do
+    let(:cores) { 6 }
+
+    it ".maximum should return 6" do
+      expect(described_class.maximum).to eq(6)
+    end
+
+    it ".fifty_percent should return 3" do
+      expect(described_class.fifty_percent).to eq(3)
+    end
+
+    it ".seventy_five_percent should return 4" do
+      expect(described_class.seventy_five_percent).to eq(4)
+    end
+
+    it ".twenty_five_percent should return 1" do
+      expect(described_class.twenty_five_percent).to eq(1)
+    end
+
+    it ".max_minus_one should return 5" do
+      expect(described_class.max_minus_one).to eq(5)
+    end
+
+    it ".max_minus_two should return 4" do
+      expect(described_class.max_minus_two).to eq(4)
+    end
+  end
+
+  context 'when the machine has 4 cores' do
+    let(:cores) { 4 }
+
+    it ".maximum should return 4" do
+      expect(described_class.maximum).to eq(4)
+    end
+
+    it ".fifty_percent should return 2" do
+      expect(described_class.fifty_percent).to eq(2)
+    end
+
+    it ".seventy_five_percent should return 3" do
+      expect(described_class.seventy_five_percent).to eq(3)
+    end
+
+    it ".twenty_five_percent should return 1" do
+      expect(described_class.twenty_five_percent).to eq(1)
+    end
+
+    it ".max_minus_one should return 3" do
+      expect(described_class.max_minus_one).to eq(3)
+    end
+
+    it ".max_minus_two should return 2" do
+      expect(described_class.max_minus_two).to eq(2)
+    end
+  end
+
+  context 'when the machine has 2 cores' do
+    let(:cores) { 2 }
+
+    it ".maximum should return 2" do
+      expect(described_class.maximum).to eq(2)
+    end
+
+    it ".fifty_percent should return 1" do
+      expect(described_class.fifty_percent).to eq(1)
+    end
+
+    it ".seventy_five_percent should return 1" do
+      expect(described_class.seventy_five_percent).to eq(1)
+    end
+
+    it ".twenty_five_percent should return 1" do
+      expect(described_class.twenty_five_percent).to eq(1)
+    end
+
+    it ".max_minus_one should return 1" do
+      expect(described_class.max_minus_one).to eq(1)
+    end
+
+    it ".max_minus_two should return 1" do
+      expect(described_class.max_minus_two).to eq(1)
+    end
+  end
+
+  context 'when the machine has 1 core' do
+    let(:cores) { 1 }
+
+    it ".maximum should return 1" do
+      expect(described_class.maximum).to eq(1)
+    end
+
+    it ".fifty_percent should return 1" do
+      expect(described_class.fifty_percent).to eq(1)
+    end
+
+    it ".seventy_five_percent should return 1" do
+      expect(described_class.seventy_five_percent).to eq(1)
+    end
+
+    it ".twenty_five_percent should return 1" do
+      expect(described_class.twenty_five_percent).to eq(1)
+    end
+
+    it ".max_minus_one should return 1" do
+      expect(described_class.max_minus_one).to eq(1)
+    end
+
+    it ".max_minus_two should return 1" do
+      expect(described_class.max_minus_two).to eq(1)
+    end
+  end
+
+end

data/spec/logstash/config/defaults_spec.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+require "spec_helper"
+require "logstash/config/defaults"
+
+describe LogStash::Config::Defaults do
+  it ".cpu_cores should return a positive integer" do
+    expect(described_class.cpu_cores.nil?).to be false
+    expect(described_class.cpu_cores.zero?).to be false
+  end
+end

data/spec/logstash/config/mixin_spec.rb

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