logstash-core 5.6.16-java → 6.0.0.alpha1-java

data/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

data/spec/logstash/config/string_escape_spec.rb

@@ -1,24 +0,0 @@
-
-require "logstash/config/string_escape"
-
-describe LogStash::Config::StringEscape do
-  let(:result) { described_class.process_escapes(text) }
-
-  table = {
-    '\\"' => '"',
-    "\\'" => "'",
-    "\\n" => "\n",
-    "\\r" => "\r",
-    "\\t" => "\t",
-    "\\\\" => "\\",
-  }
-
-  table.each do |input, expected|
-    context "when processing #{input.inspect}" do
-      let(:text) { input }
-      it "should produce #{expected.inspect}" do
-        expect(result).to be == expected
-      end
-    end
-  end
-end

data/spec/logstash/instrument/periodic_poller/dlq_spec.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-require "logstash/instrument/periodic_poller/dlq"
-require "logstash/instrument/collector"
-
-describe LogStash::Instrument::PeriodicPoller::DeadLetterQueue do
-  subject { LogStash::Instrument::PeriodicPoller::DeadLetterQueue }
-
-  let(:metric) { LogStash::Instrument::Metric.new(LogStash::Instrument::Collector.new) }
-  let(:agent) { double("agent")}
-  let(:options) { {} }
-  subject(:dlq) { described_class.new(metric, agent, options) }
-
-  it "should initialize cleanly" do
-    expect { dlq }.not_to raise_error
-  end
-end

data/spec/logstash/modules/logstash_config_spec.rb

@@ -1,56 +0,0 @@
-# encoding: utf-8
-require "logstash/modules/logstash_config"
-
-describe LogStash::Modules::LogStashConfig do
-  let(:mod) { instance_double("Modules", :directory => Stud::Temporary.directory, :module_name => "testing") }
-  let(:settings) { {"var.logstash.testing.pants" => "fancy" }}
-  subject { described_class.new(mod, settings) }
-
-  describe "configured inputs" do
-    context "when no inputs is send" do
-      it "returns the default" do
-        expect(subject.configured_inputs(["kafka"])).to include("kafka")
-      end
-    end
-
-    context "when inputs are send" do
-      let(:settings) { { "var.inputs" => "tcp" } }
-
-      it "returns the configured inputs" do
-        expect(subject.configured_inputs(["kafka"])).to include("tcp")
-      end
-
-      context "when alias is specified" do
-        let(:settings) { { "var.inputs" => "smartconnector" } }
-
-        it "returns the configured inputs" do
-          expect(subject.configured_inputs(["kafka"], { "smartconnector" => "tcp"  })).to include("tcp", "smartconnector")
-        end
-      end
-    end
-  end
-
-  describe "array to logstash array string" do
-    it "return an escaped string" do
-      expect(subject.array_to_string(["hello", "ninja"])).to eq("['hello', 'ninja']")
-    end
-  end
-
-  describe "alias modules options" do
-    let(:alias_table) do
-      { "var.logstash.testing" => "var.logstash.better" }
-    end
-
-    before do
-      subject.alias_settings_keys!(alias_table)
-    end
-
-    it "allow to retrieve settings" do
-      expect(subject.setting("var.logstash.better.pants", "dont-exist")).to eq("fancy")
-    end
-
-    it "allow to retrieve settings with the original name" do
-      expect(subject.setting("var.logstash.testing.pants", "dont-exist")).to eq("fancy")
-    end
-  end
-end

data/spec/logstash/modules/scaffold_spec.rb

@@ -1,234 +0,0 @@
-# encoding: utf-8
-#
-require "logstash/namespace"
-require "logstash/elasticsearch_client"
-require "logstash/modules/kibana_client"
-require "logstash/modules/kibana_config"
-require "logstash/modules/scaffold"
-require "logstash/modules/elasticsearch_importer"
-require "logstash/modules/kibana_importer"
-
-require_relative "../../support/helpers"
-
-describe LogStash::Modules::Scaffold do
-  let(:base_dir) { "gem-home" }
-  let(:mname) { "foo" }
-  subject(:test_module) { described_class.new(mname, base_dir) }
-  let(:module_settings) do
-    {
-      "var.elasticsearch.hosts" => "es.mycloud.com:9200",
-      "var.elasticsearch.user" => "foo",
-      "var.elasticsearch.password" => "password",
-      "var.input.tcp.port" => 5606,
-    }
-  end
-  let(:dashboard_hash) do
-    {
-      "hits" => 0,
-      "timeRestore" => false,
-      "description" => "",
-      "title" => "Filebeat Apache2 Dashboard",
-      "uiStateJSON" => "{}",
-      "panelsJSON" => '[{"col":1,"id":"foo-c","panelIndex":1,"row":1,"size_x":12,"size_y":3,"type":"visualization"},{"id":"foo-d","type":"search","panelIndex":7,"size_x":12,"size_y":3,"col":1,"row":11,"columns":["apache2.error.client","apache2.error.level","apache2.error.module","apache2.error.message"],"sort":["@timestamp","desc"]}]',
-      "optionsJSON" => "{}",
-      "version" => 1,
-      "kibanaSavedObjectMeta" => {
-        "searchSourceJSON" => "{}"
-      }
-    }
-  end
-  let(:viz_hash) do
-    {
-      "visState" => "",
-      "description" => "",
-      "title" => "foo-c",
-      "uiStateJSON" => "",
-      "version" => 1,
-      "savedSearchId" => "foo-e",
-      "kibanaSavedObjectMeta" => {}
-    }
-  end
-  let(:index_pattern_hash) do
-    {
-      "title" => "foo-*",
-      "timeFieldName" =>"time",
-      "fieldFormatMap" => "{some map}",
-      "fields" => "[some array]"
-    }
-  end
-  context "logstash operation" do
-    let(:ls_conf) do
-<<-ERB
-input {
-  tcp {
-    port => <%= setting("var.input.tcp.port", 45) %>
-    host => <%= setting("var.input.tcp.host", "localhost") %>
-    type => <%= setting("var.input.tcp.type", "server") %>
-  }
-}
-filter {
-
-}
-output {
-  <%= elasticsearch_output_config() %>
-}
-ERB
-    end
-
-    before do
-      allow(LogStash::Modules::FileReader).to receive(:read).and_return(ls_conf)
-    end
-
-    it "provides a logstash config" do
-      expect(test_module.logstash_configuration).to be_nil
-      test_module.with_settings(module_settings)
-      expect(test_module.logstash_configuration).not_to be_nil
-      config_string = test_module.config_string
-      expect(config_string).to include("port => 5606")
-      expect(config_string).to include("hosts => ['es.mycloud.com:9200']")
-    end
-  end
-
-  context "elasticsearch operation" do
-    it "provides the elasticsearch mapping file paths" do
-      test_module.with_settings(module_settings)
-      expect(test_module.elasticsearch_configuration).not_to be_nil
-      files = test_module.elasticsearch_configuration.resources
-      expect(files.size).to eq(1)
-      expect(files.first).to be_a(LogStash::Modules::ElasticsearchResource)
-      expect(files.first.content_path).to eq("gem-home/elasticsearch/foo.json")
-      expect(files.first.import_path).to eq("_template/foo")
-    end
-  end
-
-  context "kibana operation" do
-    before do
-      # allow(LogStash::Modules::FileReader).to receive(:read_json).and_return({})
-      allow(LogStash::Modules::FileReader).to receive(:read_json).with("gem-home/kibana/dashboard/foo.json").and_return(["Foo-Dashboard"])
-      allow(LogStash::Modules::FileReader).to receive(:read_json).with("gem-home/kibana/dashboard/Foo-Dashboard.json").and_return(dashboard_hash)
-      allow(LogStash::Modules::FileReader).to receive(:read_json).with("gem-home/kibana/visualization/foo-c.json").and_return(viz_hash)
-      allow(LogStash::Modules::FileReader).to receive(:read_json).with("gem-home/kibana/search/foo-d.json").and_return({"d" => "search"})
-      allow(LogStash::Modules::FileReader).to receive(:read_json).with("gem-home/kibana/search/foo-e.json").and_return({"e" => "search"})
-      allow(LogStash::Modules::FileReader).to receive(:read_json).with("gem-home/kibana/index-pattern/foo.json").and_return(index_pattern_hash)
-    end
-
-    it "provides a list of importable files" do
-      expect(test_module.kibana_configuration).to be_nil
-      test_module.with_settings(module_settings)
-      expect(test_module.kibana_configuration).not_to be_nil
-      resources = test_module.kibana_configuration.resources
-      expect(resources.size).to eq(2)
-      resource1 = resources[0]
-      resource2 = resources[1]
-      expect(resource1).to be_a(LogStash::Modules::KibanaSettings)
-      expect(resource2).to be_a(LogStash::Modules::KibanaDashboards)
-      expect(resource1.import_path).to eq("api/kibana/settings")
-      expect(resource1.content).to be_a(Array)
-      expect(resource1.content.size).to eq(1)
-
-      test_object = resource1.content[0]
-      expect(test_object).to be_a(LogStash::Modules::KibanaSettings::Setting)
-      expect(test_object.name).to eq("defaultIndex")
-      expect(test_object.value).to eq("foo-*")
-
-      expect(resource2.import_path).to eq("api/kibana/dashboards/import")
-      expect(resource2.content).to be_a(Array)
-      expect(resource2.content.size).to eq(5)
-      expect(resource2.content.map{|o| o.class}.uniq).to eq([LogStash::Modules::KibanaResource])
-
-      test_object = resource2.content[0]
-      expect(test_object.content_id).to eq("foo-*")
-      expect(test_object.content_type).to eq("index-pattern")
-      expect(test_object.content_as_object).to eq(index_pattern_hash)
-
-      test_object = resource2.content[1]
-      expect(test_object.content_id).to eq("Foo-Dashboard")
-      expect(test_object.content_type).to eq("dashboard")
-      expect(test_object.content_as_object).to eq(dashboard_hash)
-
-      test_object = resource2.content[2]
-      expect(test_object.content_id).to eq("foo-c") #<- the panels can contain items from other folders
-      expect(test_object.content_type).to eq("visualization")
-      expect(test_object.content_as_object).to eq(viz_hash)
-      expect(test_object.content_as_object["savedSearchId"]).to eq("foo-e")
-
-      test_object = resource2.content[3]
-      expect(test_object.content_id).to eq("foo-d") #<- the panels can contain items from other folders
-      expect(test_object.content_type).to eq("search")
-      expect(test_object.content_as_object).to eq("d"=>"search")
-
-      test_object = resource2.content[4]
-      expect(test_object.content_id).to eq("foo-e") # <- the visualization can contain items from the search folder
-      expect(test_object.content_type).to eq("search")
-      expect(test_object.content_as_object).to eq("e"=>"search")
-    end
-  end
-
-  context "importing to elasticsearch stubbed client" do
-    let(:mname) { "tester" }
-    let(:base_dir) { File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "modules_test_files", "modules", "#{mname}", "configuration")) }
-    let(:response) { double(:response) }
-    let(:client) { double(:client) }
-    let(:kbnclient) { double(:kbnclient) }
-    let(:paths) { [] }
-    let(:expected_paths) { ["_template/tester", "api/kibana/settings", "api/kibana/dashboards/import"] }
-    let(:contents) { [] }
-    let(:expected_objects) do
-      [
-        "index-pattern tester-*",
-        "dashboard FW-Dashboard",
-        "visualization FW-Viz-1",
-        "visualization FW-Viz-2",
-        "search Search-Tester"
-      ]
-    end
-
-    before do
-      allow(response).to receive(:status).and_return(404)
-      allow(client).to receive(:head).and_return(response)
-      allow(kbnclient).to receive(:version).and_return("9.8.7-6")
-    end
-
-    it "calls the import method" do
-      expect(client).to receive(:put).once do |path, content|
-        paths << path
-        LogStash::ElasticsearchClient::Response.new(201, "", {})
-      end
-      expect(kbnclient).to receive(:post).twice do |path, content|
-        paths << path
-        contents << content
-        LogStash::Modules::KibanaClient::Response.new(201, "", {})
-      end
-      test_module.with_settings(module_settings)
-      test_module.import(LogStash::Modules::ElasticsearchImporter.new(client), LogStash::Modules::KibanaImporter.new(kbnclient))
-      expect(paths).to eq(expected_paths)
-      expect(contents[0]).to eq({"changes"=>{"defaultIndex"=>"tester-*"}})
-      second_kbn_post = contents[1]
-      expect(second_kbn_post[:version]).to eq("9.8.7-6")
-      expect(second_kbn_post[:objects]).to be_a(Array)
-      expect(second_kbn_post[:objects].size).to eq(5)
-      objects_types_ids = second_kbn_post[:objects].map {|h| "#{h["type"]} #{h["id"]}"}
-      expect(objects_types_ids).to eq(expected_objects)
-    end
-  end
-
-  context "import 4 realz", :skip => "integration" do
-    let(:mname) { "cef" }
-    let(:base_dir) { File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "modules_test_files", "#{mname}")) }
-    let(:module_settings) do
-      {
-        "var.elasticsearch.hosts" => "localhost:9200",
-        "var.elasticsearch.user" => "foo",
-        "var.elasticsearch.password" => "password",
-        "var.input.tcp.port" => 5606,
-      }
-    end
-    it "puts stuff in ES" do
-      test_module.with_settings(module_settings)
-      client = LogStash::ElasticsearchClient.build(module_settings)
-      import_engine = LogStash::Modules::Importer.new(client)
-      test_module.import(import_engine)
-      expect(1).to eq(1)
-    end
-  end
-end

data/spec/logstash/pipeline_dlq_commit_spec.rb

@@ -1,109 +0,0 @@
-# encoding: utf-8
-require "tmpdir"
-require "spec_helper"
-require "logstash/codecs/plain"
-require_relative "../support/mocks_classes"
-
-class SingleGeneratorInput < LogStash::Inputs::Base
-  config_name "singlegenerator"
-  milestone 2
-
-  def register
-  end
-
-  def run(queue)
-    queue << LogStash::Event.new
-  end
-
-  def close
-  end
-end
-
-class DLQCommittingFilter < LogStash::Filters::Base
-  config_name "dlq_commit"
-  milestone 2
-
-  def register()
-  end
-
-  def filter(event)
-    execution_context.dlq_writer.write(event, "my reason")
-  end
-
-  def threadsafe?() true; end
-
-  def close() end
-end
-
-describe LogStash::Pipeline do
-  let(:pipeline_settings_obj) { LogStash::SETTINGS }
-  let(:pipeline_settings) do
-    {
-      "pipeline.workers" => 2,
-      "pipeline.id" => pipeline_id,
-      "dead_letter_queue.enable" => enable_dlq,
-      "path.dead_letter_queue" => Dir.mktmpdir
-    }
-  end
-  let(:metric) { LogStash::Instrument::Metric.new(LogStash::Instrument::Collector.new) }
-  let(:test_config) {
-    <<-eos
-        input { singlegenerator { id => input_id } }
-
-        filter { dlq_commit { id => filter_id } }
-
-        output { dummyoutput { id => output_id } }
-    eos
-  }
-
-  subject { LogStash::Pipeline.new(test_config, pipeline_settings_obj, metric) }
-
-  before(:each) do
-    pipeline_settings.each {|k, v| pipeline_settings_obj.set(k, v) }
-    allow(LogStash::Plugin).to receive(:lookup).with("input", "singlegenerator").and_return(SingleGeneratorInput)
-    allow(LogStash::Plugin).to receive(:lookup).with("codec", "plain").and_return(LogStash::Codecs::Plain)
-    allow(LogStash::Plugin).to receive(:lookup).with("filter", "dlq_commit").and_return(DLQCommittingFilter)
-    allow(LogStash::Plugin).to receive(:lookup).with("output", "dummyoutput").and_return(::LogStash::Outputs::DummyOutput)
-  end
-
-  after(:each) do
-    FileUtils.rm_rf(pipeline_settings["path.dead_letter_queue"])
-  end
-
-  context "dlq is enabled" do
-    let(:enable_dlq) { true }
-    let(:pipeline_id) { "test-dlq" }
-
-    it "retrieves proper pipeline-level DLQ writer" do
-      expect(LogStash::Util::PluginDeadLetterQueueWriter).to receive(:new).with(anything, "input_id", "singlegenerator").and_call_original
-      expect(LogStash::Util::PluginDeadLetterQueueWriter).to receive(:new).with(anything, "filter_id", "dlq_commit").and_call_original
-      expect(LogStash::Util::PluginDeadLetterQueueWriter).to receive(:new).with(anything, "output_id", "dummyoutput").and_call_original
-      expect_any_instance_of(org.logstash.common.io.DeadLetterQueueWriter).to receive(:close).and_call_original
-      subject.run
-      dlq_path = java.nio.file.Paths.get(pipeline_settings_obj.get("path.dead_letter_queue"), pipeline_id)
-      dlq_reader = org.logstash.common.io.DeadLetterQueueReader.new(dlq_path)
-      entry = dlq_reader.pollEntry(40)
-      expect(entry).to_not be_nil
-      expect(entry.reason).to eq("my reason")
-      subject.shutdown
-    end
-  end
-
-  context "dlq is disabled" do
-    let(:enable_dlq) { false }
-    let(:pipeline_id) { "test-without-dlq" }
-
-    it "does not write to the DLQ" do
-      expect(LogStash::Util::PluginDeadLetterQueueWriter).to receive(:new).with(anything, "input_id", "singlegenerator").and_call_original
-      expect(LogStash::Util::PluginDeadLetterQueueWriter).to receive(:new).with(anything, "filter_id", "dlq_commit").and_call_original
-      expect(LogStash::Util::PluginDeadLetterQueueWriter).to receive(:new).with(anything, "output_id", "dummyoutput").and_call_original
-      expect(LogStash::Util::DummyDeadLetterQueueWriter).to receive(:new).and_call_original
-      expect_any_instance_of(LogStash::Util::DummyDeadLetterQueueWriter).to receive(:close).and_call_original
-      subject.run
-      dlq_path = java.nio.file.Paths.get(pipeline_settings_obj.get("path.dead_letter_queue"), pipeline_id)
-      expect(java.nio.file.Files.exists(dlq_path)).to eq(false)
-      subject.shutdown
-    end
-  end
-
-end