logstash-core 2.1.3-java → 2.2.0-java

data/spec/core/runner_spec.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-require "logstash/runner"
-require "stud/task"
-
-class NullRunner
-  def run(args); end
-end
-
-describe LogStash::Runner do
-
-  context "argument parsing" do
-    it "should run agent" do
-      expect(Stud::Task).to receive(:new).once.and_return(nil)
-      args = ["agent", "-e", ""]
-      expect(subject.run(args)).to eq(nil)
-    end
-
-    it "should run agent help" do
-      expect(subject).to receive(:show_help).once.and_return(nil)
-      args = ["agent", "-h"]
-      expect(subject.run(args).wait).to eq(0)
-    end
-
-    it "should show help with no arguments" do
-      expect($stderr).to receive(:puts).once.and_return("No command given")
-      expect($stderr).to receive(:puts).once
-      args = []
-      expect(subject.run(args).wait).to eq(1)
-    end
-
-    it "should show help for unknown commands" do
-      expect($stderr).to receive(:puts).once.and_return("No such command welp")
-      expect($stderr).to receive(:puts).once
-      args = ["welp"]
-      expect(subject.run(args).wait).to eq(1)
-    end
-
-  end
-end

data/spec/core/timestamp_spec.rb

@@ -1,84 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-require "logstash/timestamp"
-
-describe LogStash::Timestamp do
-
-  it "should parse its own iso8601 output" do
-    t = Time.now
-    ts = LogStash::Timestamp.new(t)
-    expect(LogStash::Timestamp.parse_iso8601(ts.to_iso8601).to_i).to eq(t.to_i)
-  end
-
-  it "should coerce iso8601 string" do
-    t = Time.now
-    ts = LogStash::Timestamp.new(t)
-    expect(LogStash::Timestamp.coerce(ts.to_iso8601).to_i).to eq(t.to_i)
-  end
-
-  it "should coerce Time" do
-    t = Time.now
-    expect(LogStash::Timestamp.coerce(t).to_i).to eq(t.to_i)
-  end
-
-  it "should coerce Timestamp" do
-    t = LogStash::Timestamp.now
-    expect(LogStash::Timestamp.coerce(t).to_i).to eq(t.to_i)
-  end
-
-  it "should raise on invalid string coerce" do
-    expect{LogStash::Timestamp.coerce("foobar")}.to raise_error LogStash::TimestampParserError
-  end
-
-  it "should return nil on invalid object coerce" do
-    expect(LogStash::Timestamp.coerce(:foobar)).to be_nil
-  end
-
-  it "should support to_json" do
-    expect(LogStash::Timestamp.parse_iso8601("2014-09-23T00:00:00-0800").to_json).to eq("\"2014-09-23T08:00:00.000Z\"")
-  end
-
-  it "should support to_json and ignore arguments" do
-    expect(LogStash::Timestamp.parse_iso8601("2014-09-23T00:00:00-0800").to_json(:some => 1, :argumnents => "test")).to eq("\"2014-09-23T08:00:00.000Z\"")
-  end
-
-  it "should support timestamp comparaison" do
-   current = LogStash::Timestamp.new(Time.now) 
-   future = LogStash::Timestamp.new(Time.now + 100)
-
-   expect(future > current).to eq(true)
-   expect(future < current).to eq(false)
-   expect(current == current).to eq(true)
-
-   expect(current <=> current).to eq(0)
-   expect(current <=> future).to eq(-1)
-   expect(future <=> current).to eq(1)
-  end
-
-  it "should allow unary operation +" do
-    current = Time.now
-    t = LogStash::Timestamp.new(current) + 10
-    expect(t).to eq(current + 10)
-  end
-
-  describe "subtraction" do
-    it "should work on a timestamp object" do
-      t = Time.now
-      current = LogStash::Timestamp.new(t)
-      future = LogStash::Timestamp.new(t + 10)
-      expect(future - current).to eq(10)
-    end
-
-    it "should work on with time object" do
-      current = Time.now
-      t = LogStash::Timestamp.new(current + 10)
-      expect(t - current).to eq(10)
-    end
-
-    it "should work with numeric value" do
-      current = Time.now
-      t = LogStash::Timestamp.new(current + 10)
-      expect(t - 10).to eq(current)
-    end
-  end
-end

data/spec/coverage_helper.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-# Useful module to help loading all logstash content when
-# running coverage analysis
-module CoverageHelper
-
-  ##
-  # Skip list used to avoid loading certain patterns within
-  # the logstash directories, this patterns are excluded becuause
-  # of potential problems or because they are going to be loaded
-  # in another way.
-  ##
-  SKIP_LIST = Regexp.union([
-    /^lib\/bootstrap\/rspec.rb$/,
-    /^lib\/logstash\/util\/prctl.rb$/
-  ])
-
-  def self.eager_load
-    Dir.glob("lib/**/*.rb") do |file|
-      next if file =~ SKIP_LIST
-      require file
-    end
-  end
-
-end

data/spec/lib/logstash/bundler_spec.rb

@@ -1,121 +0,0 @@
-# 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/license_spec.rb

@@ -1,67 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'rakelib/default_plugins'
-
-describe "Project licenses" do
-
-  let(:expected_licenses) {
-    ##
-    # Expected licenses are Apache License 2.0, BSD license, MIT license and the ruby one,
-    # this not exclude that this list change in the feature.
-    ##
-    Regexp.union([ /mit/,
-                   /apache*/,
-                   /bsd/,
-                   /artistic 2.*/,
-                   /ruby/,
-                   /lgpl/])
-  }
-
-  ##
-  # This licenses are skipped from the license test of many reasons, check
-  # the exact dependency for detailed information.
-  ##
-  let(:skipped_dependencies) do
-    [
-      # Skipped because of already included and bundled within JRuby so checking here is redundant.
-      # Need to take action about jruby licenses to enable again or keep skeeping.
-      "jruby-openssl"
-    ]
-  end
-
-  shared_examples "runtime license test" do
-
-    subject(:gem_name) do |example|
-      example.metadata[:example_group][:parent_example_group][:description]
-    end
-
-    let(:spec) { Gem::Specification.find_all_by_name(gem_name)[0] }
-
-    it "have an expected license" do
-      spec.licenses.each do |license|
-        expect(license.downcase).to match(expected_licenses)
-      end
-    end
-
-    it "has runtime dependencies with expected licenses" do
-      spec.runtime_dependencies.map { |dep| dep.to_spec }.each do |runtime_spec|
-        next unless runtime_spec
-        next if skipped_dependencies.include?(runtime_spec.name)
-        runtime_spec.licenses.each do |license|
-          expect(license.downcase).to match(expected_licenses)
-        end
-      end
-    end
-  end
-
-  describe "logstash-core" do
-    it_behaves_like "runtime license test"
-  end
-
-  installed_plugins.each do |plugin|
-    describe plugin do
-      it_behaves_like "runtime license test"
-    end
-  end
-
-end

data/spec/outputs/base_spec.rb

@@ -1,26 +0,0 @@
-# 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

data/spec/plugin_manager/install_spec.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'pluginmanager/main'
-
-describe LogStash::PluginManager::Install do
-  let(:cmd) { LogStash::PluginManager::Install.new("install") }
-
-  before(:each) do
-    expect(cmd).to receive(:validate_cli_options!).and_return(nil)
-  end
-
-  context "when validating plugins" do
-    let(:sources) { ["https://rubygems.org", "http://localhost:9292"] }
-
-    before(:each) do
-      expect(cmd).to receive(:plugins_gems).and_return([["dummy", nil]])
-      expect(cmd).to receive(:install_gems_list!).and_return(nil)
-      expect(cmd).to receive(:remove_unused_locally_installed_gems!).and_return(nil)
-      cmd.verify = true
-    end
-
-    it "should load all the sources defined in the Gemfile" do
-      expect(cmd.gemfile.gemset).to receive(:sources).and_return(sources)
-      expect(LogStash::PluginManager).to receive(:logstash_plugin?).with("dummy", nil, {:rubygems_source => sources}).and_return(true)
-      cmd.execute
-    end
-  end
-end

data/spec/plugin_manager/update_spec.rb

@@ -1,39 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'pluginmanager/main'
-
-describe LogStash::PluginManager::Update do
-  let(:cmd)     { LogStash::PluginManager::Update.new("update") }
-  let(:sources) { cmd.gemfile.gemset.sources }
-
-  before(:each) do
-    expect(cmd).to receive(:find_latest_gem_specs).and_return({})
-    allow(cmd).to receive(:warn_local_gems).and_return(nil)
-    expect(cmd).to receive(:display_updated_plugins).and_return(nil)
-    expect_any_instance_of(LogStash::Bundler).to receive(:invoke!).with(:clean => true)
-  end
-
-  it "pass all gem sources to the bundle update command" do
-    sources = cmd.gemfile.gemset.sources
-    expect_any_instance_of(LogStash::Bundler).to receive(:invoke!).with(:update => [], :rubygems_source => sources)
-    cmd.execute
-  end
-
-  context "when skipping validation" do
-    let(:cmd)    { LogStash::PluginManager::Update.new("update") }
-    let(:plugin) { OpenStruct.new(:name => "dummy", :options => {} ) }
-
-    before(:each) do
-      expect(cmd.gemfile).to receive(:find).with(plugin).and_return(plugin)
-      expect(cmd.gemfile).to receive(:save).and_return(nil)
-      expect(cmd).to receive(:plugins_to_update).and_return([plugin])
-      expect_any_instance_of(LogStash::Bundler).to receive(:invoke!).with(:update => [plugin], :rubygems_source => sources).and_return(nil)
-    end
-
-    it "skips version verification when ask for it" do
-      cmd.verify = false
-      expect(cmd).to_not receive(:validates_version)
-      cmd.execute
-    end
-  end
-end

data/spec/plugin_manager/util_spec.rb

@@ -1,71 +0,0 @@
-#encoding: utf-8
-require 'spec_helper'
-require 'pluginmanager/util'
-require 'gems'
-
-describe LogStash::PluginManager do
-
-  describe "fetching plugin information" do
-    let(:plugin_name) { "logstash-output-elasticsearch" }
-
-    let(:version_data) do
-      [ { "authors"=>"Elastic", "built_at"=>"2015-08-11T00:00:00.000Z", "description"=>"Output events to elasticsearch",
-          "downloads_count"=>1638, "metadata"=>{"logstash_group"=>"output", "logstash_plugin"=>"true"}, "number"=>"2.0.0.pre",
-          "summary"=>"Logstash Output to Elasticsearch", "platform"=>"java", "ruby_version"=>">= 0", "prerelease"=>true,
-          "licenses"=>["apache-2.0"], "requirements"=>[], "sha"=>"194b27099c13605a882a3669e2363fdecccaab1de48dd44b0cda648dd5516799"},
-      { "authors"=>"Elastic", "built_at"=>"2015-08-10T00:00:00.000Z", "description"=>"Output events to elasticsearch",
-        "downloads_count"=>1638, "metadata"=>{"logstash_group"=>"output", "logstash_plugin"=>"true"}, "number"=>"1.0.7",
-        "summary"=>"Logstash Output to Elasticsearch", "platform"=>"java", "ruby_version"=>">= 0", "prerelease"=>false,
-        "licenses"=>["apache-2.0"], "requirements"=>[], "sha"=>"194b27099c13605a882a3669e2363fdecccaab1de48dd44b0cda648dd5516799"},
-      { "authors"=>"Elastic", "built_at"=>"2015-08-09T00:00:00.000Z", "description"=>"Output events to elasticsearch",
-        "downloads_count"=>1638, "metadata"=>{"logstash_group"=>"output", "logstash_plugin"=>"true"}, "number"=>"1.0.4",
-        "summary"=>"Logstash Output to Elasticsearch", "platform"=>"java", "ruby_version"=>">= 0", "prerelease"=>false,
-        "licenses"=>["apache-2.0"], "requirements"=>[], "sha"=>"194b27099c13605a882a3669e2363fdecccaab1de48dd44b0cda648dd5516799"} ]
-    end
-
-    before(:each) do
-      allow(Gems).to receive(:versions).with(plugin_name).and_return(version_data)
-    end
-
-    context "fetch plugin info" do
-      it "should search for the last version infomation non prerelease" do
-        version_info = LogStash::PluginManager.fetch_latest_version_info(plugin_name)
-        expect(version_info["number"]).to eq("1.0.7")
-      end
-
-
-      it "should search for the last version infomation with prerelease" do
-        version_info = LogStash::PluginManager.fetch_latest_version_info(plugin_name, :pre => true)
-        expect(version_info["number"]).to eq("2.0.0.pre")
-      end
-    end
-  end
-
-  describe "a logstash_plugin validation" do
-    let(:plugin)  { "foo" }
-    let(:version) { "9.0.0.0" }
-
-    let(:sources) { ["http://source.01", "http://source.02"] }
-    let(:options) { {:rubygems_source => sources} }
-
-    let(:gemset)  { double("gemset") }
-    let(:gemfile) { double("gemfile") }
-    let(:dep)     { double("dep") }
-    let(:fetcher) { double("fetcher") }
-
-    before(:each) do
-      allow(gemfile).to  receive(:gemset).and_return(gemset)
-      allow(gemset).to   receive(:sources).and_return(sources)
-      expect(fetcher).to receive(:spec_for_dependency).and_return([[],[]])
-    end
-
-    it "should load all available sources" do
-      expect(subject).to receive(:plugin_file?).and_return(false)
-      expect(Gem::Dependency).to receive(:new).and_return(dep)
-      expect(Gem::SpecFetcher).to receive(:fetcher).and_return(fetcher)
-
-      subject.logstash_plugin?(plugin, version, options)
-      expect(Gem.sources.map { |source| source }).to eq(sources)
-    end
-  end
-end