fluentd 0.12.0.pre.1 → 0.12.0.pre.2

data/spec/config/section_spec.rb

@@ -1,97 +0,0 @@
-require 'fluent/config/section'
-
-describe Fluent::Config::Section do
-  context 'class' do
-    describe '.name' do
-      it 'returns its full module name as String' do
-        expect(Fluent::Config::Section.name).to eql('Fluent::Config::Section')
-      end
-    end
-  end
-
-  context 'instance object' do
-    describe '#initialize' do
-      it 'creates blank object without argument' do
-        s = Fluent::Config::Section.new
-        expect(s.instance_eval{ @params }).to eql({})
-      end
-
-      it 'creates object which contains specified hash object itself' do
-        hash = {
-          name: 'tagomoris',
-          age: 34,
-          send: 'email',
-          class: 'normal',
-          keys: 5,
-        }
-        s1 = Fluent::Config::Section.new(hash)
-        expect(s1.instance_eval{ @params }).to eq(hash)
-        expect(s1[:name]).to eql("tagomoris")
-        expect(s1[:age]).to eql(34)
-        expect(s1[:send]).to eql("email")
-        expect(s1[:class]).to eql("normal")
-        expect(s1[:keys]).to eql(5)
-
-        expect(s1.name).to eql("tagomoris")
-        expect(s1.age).to eql(34)
-        expect(s1.send).to eql("email")
-        expect(s1.class).to eql("normal")
-        expect(s1.keys).to eql(5)
-
-        expect{ s1.dup }.to raise_error(NoMethodError)
-      end
-    end
-
-    describe '#to_h' do
-      it 'returns internal hash itself' do
-        hash = {
-          name: 'tagomoris',
-          age: 34,
-          send: 'email',
-          class: 'normal',
-          keys: 5,
-        }
-        s = Fluent::Config::Section.new(hash)
-        expect(s.to_h).to eq(hash)
-        expect(s.to_h.class).to eq(Hash)
-      end
-    end
-
-    describe '#instance_of?' do
-      it 'can judge whether it is a Section object or not' do
-        s = Fluent::Config::Section.new
-        expect(s.instance_of?(Fluent::Config::Section)).to be true
-        expect(s.instance_of?(BasicObject)).to be false
-      end
-    end
-
-    describe '#is_a?' do
-      it 'can judge whether it belongs to or not' do
-        s = Fluent::Config::Section.new
-        expect(s.is_a?(Fluent::Config::Section)).to be true
-        expect(s.kind_of?(Fluent::Config::Section)).to be true
-        expect(s.is_a?(BasicObject)).to be true
-      end
-    end
-
-    describe '#+' do
-      it 'can merge 2 sections: argument side is primary, internal hash is newly created' do
-        h1 = {name: "s1", num: 10, class: "A"}
-        s1 = Fluent::Config::Section.new(h1)
-
-        h2 = {name: "s2", class: "A", num2: "5", num3: "8"}
-        s2 = Fluent::Config::Section.new(h2)
-        s = s1 + s2
-
-        expect(s.to_h.object_id).not_to eq(h1.object_id)
-        expect(s.to_h.object_id).not_to eq(h2.object_id)
-
-        expect(s.name).to eql("s2")
-        expect(s.num).to eql(10)
-        expect(s.class).to eql("A")
-        expect(s.num2).to eql("5")
-        expect(s.num3).to eql("8")
-      end
-    end
-  end
-end

data/spec/config/system_config_spec.rb

@@ -1,49 +0,0 @@
-require 'fluent/configurable'
-require 'fluent/config/element'
-require 'fluent/config/section'
-require 'fluent/supervisor'
-
-describe Fluent::Supervisor::SystemConfig do
-  def parse_text(text)
-    basepath = File.expand_path(File.dirname(__FILE__) + '/../../')
-    Fluent::Config.parse(text, '(test)', basepath, true).elements.find { |e| e.name == 'system' }
-  end
-
-  it 'should not override default configurations when no parameters' do
-    conf = parse_text(<<EOS)
-<system>
-</system>
-EOS
-    sc = Fluent::Supervisor::SystemConfig.new(conf)
-    expect(sc.log_level).to be_nil
-    expect(sc.suppress_repeated_stacktrace).to be_nil
-    expect(sc.emit_error_log_interval).to be_nil
-    expect(sc.suppress_config_dump).to be_nil
-    expect(sc.without_source).to be_nil
-    expect(sc.to_opt).to eql({})
-  end
-
-  {'log_level' => 'error', 'suppress_repeated_stacktrace' => true, 'emit_error_log_interval' => 60, 'suppress_config_dump' => true, 'without_source' => true}.each { |k, v|
-    it "accepts #{k} parameter" do
-      conf = parse_text(<<EOS)
-<system>
-  #{k} #{v}
-</system>
-EOS
-      sc = Fluent::Supervisor::SystemConfig.new(conf)
-      expect(sc.instance_variable_get("@#{k}")).not_to be_nil
-      if k == 'emit_error_log_interval'
-        expect(sc.to_opt).to include(:suppress_interval)
-      else
-        expect(sc.to_opt).to include(k.to_sym)
-      end
-    end
-  }
-
-  {'foo' => 'bar', 'hoge' => 'fuga'}.each { |k, v|
-    it "should not affect settable parameters with unknown #{k} parameter" do
-      sc = Fluent::Supervisor::SystemConfig.new({k => v})
-      expect(sc.to_opt).to be_empty
-    end
-  }
-end

data/spec/spec_helper.rb

@@ -1,60 +0,0 @@
-
-require 'fluent/load'
-require 'fileutils'
-
-src_root = File.expand_path('..', File.dirname(__FILE__))
-$LOAD_PATH << File.join(src_root, "lib")
-$LOAD_PATH << src_root
-
-if ENV['SIMPLE_COV']
-  require 'simplecov'
-  if defined?(SimpleCov::SourceFile)
-    mod = SimpleCov::SourceFile
-    def mod.new(*args, &block)
-      m = allocate
-      m.instance_eval do
-        begin
-          initialize(*args, &block)
-        rescue Encoding::UndefinedConversionError
-          @src = "".force_encoding('UTF-8')
-        end
-      end
-      m
-    end
-  end
-  SimpleCov.start do
-    add_filter 'spec/'
-    add_filter 'pkg/'
-    add_filter 'vendor/'
-  end
-end
-
-if ENV['GC_STRESS']
-  STDERR.puts "enable GC.stress"
-  GC.stress = true
-end
-
-require 'fluent/log'
-require 'fluent/plugin'
-
-class DummyLogDevice
-  attr_reader :logs
-  def initialize ; @logs = [] ; end
-  def tty? ; false ; end
-  def puts(*args) ; args.each{ |arg| write(arg + "\n") } ; end
-  def write(message) ; @logs.push message ; end
-  def flush ; true ; end
-  def close ; true ; end
-end
-
-class TestLogger < Fluent::PluginLogger
-  def initialize
-    @logdev = DummyLogDevice.new
-    super(Fluent::Log.new(@logdev))
-  end
-  def logs
-    @logdev.logs
-  end
-end
-
-$log ||= TestLogger.new