logstash-output-scalyr 0.2.0 → 0.2.3

data/vendor/bundle/jruby/2.5.0/gems/logstash-core-5.6.4-java/spec/logstash/config/config_ast_spec.rb

@@ -1,263 +0,0 @@
-# encoding: utf-8
-# config syntax tests
-#
-require "spec_helper"
-require "logstash/config/grammar"
-require "logstash/config/config_ast"
-
-describe LogStashConfigParser do
-  let(:settings) { mock_settings({}) }
-
-  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
-
-    context "when config.support_escapes" do
-      let(:parser) { LogStashConfigParser.new }
-
-      let(:processed_value)  { 'The computer says, "No"' }
-
-      let(:config) {
-        parser.parse(%q(
-          input {
-            foo {
-              bar => "The computer says, \"No\""
-            }
-          }
-        ))
-      }
-
-      let(:compiled_string) { eval(config.recursive_select(LogStash::Config::AST::String).first.compile) }
-
-      before do
-        config.process_escape_sequences = escapes
-      end
-
-      context "is enabled" do
-        let(:escapes) { true }
-
-        it "should process escape sequences" do
-          expect(compiled_string).to be == processed_value
-        end
-      end
-
-      context "is false" do
-        let(:escapes) { false }
-
-        it "should not process escape sequences" do
-          expect(compiled_string).not_to be == processed_value
-        end
-      end
-    end
-  end
-
-  context "when using two plugin sections of the same type" do
-    let(:pipeline_klass) do
-      Class.new do
-        def initialize(config, settings)
-          grammar = LogStashConfigParser.new
-          @config = grammar.parse(config)
-          @code = @config.compile
-          eval(@code)
-        end
-        def plugin(*args);end
-      end
-    end
-    context "(filters)" do
-      let(:config_string) {
-        "input { generator { } }
-         filter { filter1 { } }
-         filter { filter1 { } }
-         output { output1 { } }"
-      }
-
-
-      it "should create a pipeline with both sections" do
-        generated_objects = pipeline_klass.new(config_string, settings).instance_variable_get("@generated_objects")
-        filters = generated_objects.keys.map(&:to_s).select {|obj_name| obj_name.match(/^filter.+?_\d+$/) }
-        expect(filters.size).to eq(2)
-      end
-    end
-
-    context "(filters)" do
-      let(:config_string) {
-        "input { generator { } }
-         output { output1 { } }
-         output { output1 { } }"
-      }
-
-
-      it "should create a pipeline with both sections" do
-        generated_objects = pipeline_klass.new(config_string, settings).instance_variable_get("@generated_objects")
-        outputs = generated_objects.keys.map(&:to_s).select {|obj_name| obj_name.match(/^output.+?_\d+$/) }
-        expect(outputs.size).to eq(2)
-      end
-    end
-  end
-  context "when creating two instances of the same configuration" do
-    let(:config_string) {
-      "input { generator { } }
-       filter {
-         if [type] == 'test' { filter1 { } }
-       }
-       output {
-         output1 { }
-       }"
-    }
-
-    let(:pipeline_klass) do
-      Class.new do
-        def initialize(config, settings)
-          grammar = LogStashConfigParser.new
-          @config = grammar.parse(config)
-          @code = @config.compile
-          eval(@code)
-        end
-        def plugin(*args);end
-      end
-    end
-
-    describe "generated conditional functionals" do
-      it "should be created per instance" do
-        instance_1 = pipeline_klass.new(config_string, settings)
-        instance_2 = pipeline_klass.new(config_string, settings)
-        generated_method_1 = instance_1.instance_variable_get("@generated_objects")[:cond_func_1]
-        generated_method_2 = instance_2.instance_variable_get("@generated_objects")[:cond_func_1]
-        expect(generated_method_1).to_not be(generated_method_2)
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/logstash-core-5.6.4-java/spec/logstash/config/cpu_core_strategy_spec.rb

@@ -1,123 +0,0 @@
-# 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/vendor/bundle/jruby/2.5.0/gems/logstash-core-5.6.4-java/spec/logstash/config/defaults_spec.rb

@@ -1,10 +0,0 @@
-# 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/vendor/bundle/jruby/2.5.0/gems/logstash-core-5.6.4-java/spec/logstash/config/loader_spec.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-require "logstash/config/loader"
-
-describe LogStash::Config::Loader do
-  let(:logger) { double("logger") }
-  subject { described_class.new(logger) }
-
-  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" }
-      let(:dummy_config) { 'input {}' }
-
-      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