fluentd 0.10.62 → 0.12.0.pre.1

data/test/config/test_section.rb

@@ -1,112 +0,0 @@
-require_relative '../helper'
-require 'fluent/config/section'
-
-module Fluent::Config
-  class TestSection < ::Test::Unit::TestCase
-    sub_test_case Fluent::Config::Section do
-      sub_test_case 'class' do
-        sub_test_case '.name' do
-          test 'returns its full module name as String' do
-            assert_equal('Fluent::Config::Section', Fluent::Config::Section.name)
-          end
-        end
-      end
-
-      sub_test_case 'instance object' do
-        sub_test_case '#initialize' do
-          test 'creates blank object without argument' do
-            s = Fluent::Config::Section.new
-            assert_equal({}, s.instance_eval{ @params })
-          end
-
-          test '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)
-            assert_equal(hash, s1.instance_eval { @params })
-            assert_equal("tagomoris", s1[:name])
-            assert_equal(34, s1[:age])
-            assert_equal("email", s1[:send])
-            assert_equal("normal", s1[:class])
-            assert_equal(5, s1[:keys])
-
-            assert_equal("tagomoris", s1.name)
-            assert_equal(34, s1.age)
-            assert_equal("email", s1.send)
-            assert_equal("normal", s1.class)
-            assert_equal(5, s1.keys)
-
-            assert_raise(NoMethodError) { s1.dup }
-          end
-        end
-
-        sub_test_case '#object_id' do
-          test 'returns its object id' do
-            s1 = Fluent::Config::Section.new({})
-            assert s1.object_id
-            s2 = Fluent::Config::Section.new({})
-            assert s2.object_id
-            assert_not_equal s1.object_id, s2.object_id
-          end
-        end
-
-        sub_test_case '#to_h' do
-          test 'returns internal hash itself' do
-            hash = {
-              name: 'tagomoris',
-              age: 34,
-              send: 'email',
-              class: 'normal',
-              keys: 5,
-            }
-            s = Fluent::Config::Section.new(hash)
-            assert_equal(hash, s.to_h)
-            assert_instance_of(Hash, s.to_h)
-          end
-        end
-
-        sub_test_case '#instance_of?' do
-          test 'can judge whether it is a Section object or not' do
-            s = Fluent::Config::Section.new
-            assert_true(s.instance_of?(Fluent::Config::Section))
-            assert_false(s.instance_of?(BasicObject))
-          end
-        end
-
-        sub_test_case '#is_a?' do
-          test 'can judge whether it belongs to or not' do
-            s = Fluent::Config::Section.new
-            assert_true(s.is_a?(Fluent::Config::Section))
-            assert_true(s.kind_of?(Fluent::Config::Section))
-            assert_true(s.is_a?(BasicObject))
-          end
-        end
-
-        sub_test_case '#+' do
-          test '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
-
-            assert_not_equal(h1.object_id, s.to_h.object_id)
-            assert_not_equal(h2.object_id, s.to_h.object_id)
-
-            assert_equal("s2", s.name)
-            assert_equal(10, s.num)
-            assert_equal("A", s.class)
-            assert_equal("5", s.num2)
-            assert_equal("8", s.num3)
-          end
-        end
-      end
-    end
-  end
-end

data/test/config/test_system_config.rb

@@ -1,99 +0,0 @@
-require_relative '../helper'
-require 'fluent/configurable'
-require 'fluent/config/element'
-require 'fluent/config/section'
-require 'fluent/supervisor'
-
-module Fluent::Config
-  class FakeLoggerInitializer
-    attr_accessor :level
-    def initalize
-      @level = nil
-    end
-  end
-
-  class FakeSupervisor
-    def initialize
-      @log = FakeLoggerInitializer.new
-      @log_level = nil
-      @suppress_interval = nil
-      @suppress_config_dump = nil
-      @suppress_repeated_stacktrace = nil
-      @without_source = nil
-    end
-  end
-
-  class TestSystemConfig < ::Test::Unit::TestCase
-
-    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
-
-    test 'should not override default configurations when no parameters' do
-      conf = parse_text(<<-EOS)
-        <system>
-        </system>
-      EOS
-      s = FakeSupervisor.new
-      sc = Fluent::Supervisor::SystemConfig.new(conf)
-      sc.apply(s)
-      assert_nil(sc.log_level)
-      assert_nil(sc.suppress_repeated_stacktrace)
-      assert_nil(sc.emit_error_log_interval)
-      assert_nil(sc.suppress_config_dump)
-      assert_nil(sc.without_source)
-      assert_nil(s.instance_variable_get(:@log_level))
-      assert_nil(s.instance_variable_get(:@suppress_repeated_stacktrace))
-      assert_nil(s.instance_variable_get(:@emit_error_log_interval))
-      assert_nil(s.instance_variable_get(:@suppress_config_dump))
-      assert_nil(s.instance_variable_get(:@without_source))
-    end
-
-    {'log_level' => 'error',
-     'suppress_repeated_stacktrace' => true,
-     'emit_error_log_interval' => 60,
-     'suppress_config_dump' => true,
-     'without_source' => true,
-    }.each { |k, v|
-      test "accepts #{k} parameter" do
-        conf = parse_text(<<-EOS)
-          <system>
-            #{k} #{v}
-          </system>
-        EOS
-        s = FakeSupervisor.new
-        sc = Fluent::Supervisor::SystemConfig.new(conf)
-        sc.apply(s)
-        assert_not_nil(sc.instance_variable_get("@#{k}"))
-        key = (k == 'emit_error_log_interval' ? 'suppress_interval' : k)
-        assert_not_nil(s.instance_variable_get("@#{key}"))
-      end
-    }
-
-    {'foo' => 'bar', 'hoge' => 'fuga'}.each { |k, v|
-      test "should not affect settable parameters with unknown #{k} parameter" do
-        s = FakeSupervisor.new
-        sc = Fluent::Supervisor::SystemConfig.new({k => v})
-        sc.apply(s)
-        assert_nil(s.instance_variable_get(:@log_level))
-        assert_nil(s.instance_variable_get(:@suppress_repeated_stacktrace))
-        assert_nil(s.instance_variable_get(:@emit_error_log_interval))
-        assert_nil(s.instance_variable_get(:@suppress_config_dump))
-        assert_nil(s.instance_variable_get(:@without_source))
-      end
-    }
-
-    test 'log_level' do
-      conf = parse_text(<<-EOS)
-        <system>
-          log_level warn
-        </system>
-      EOS
-      s = FakeSupervisor.new
-      sc = Fluent::Supervisor::SystemConfig.new(conf)
-      sc.apply(s)
-      assert_equal(Fluent::Log::LEVEL_WARN, s.instance_variable_get("@log").level)
-    end
-  end
-end

data/test/config/test_types.rb

@@ -1,63 +0,0 @@
-require 'helper'
-require 'fluent/config/types'
-
-class TestConfigTypes < ::Test::Unit::TestCase
-  include Fluent
-
-  sub_test_case 'Config.size_value' do
-    test 'normal case' do
-      assert_equal(2048, Config.size_value("2k"))
-      assert_equal(2048, Config.size_value("2K"))
-      assert_equal(3145728, Config.size_value("3m"))
-      assert_equal(3145728, Config.size_value("3M"))
-      assert_equal(4294967296, Config.size_value("4g"))
-      assert_equal(4294967296, Config.size_value("4G"))
-      assert_equal(5497558138880, Config.size_value("5t"))
-      assert_equal(5497558138880, Config.size_value("5T"))
-      assert_equal(6, Config.size_value("6"))
-    end
-
-    test 'not assumed case' do
-      assert_equal(6, Config.size_value(6))
-      assert_equal(0, Config.size_value("hoge"))
-      assert_equal(0, Config.size_value(""))
-      assert_equal(0, Config.size_value(nil))
-    end
-  end
-
-  sub_test_case 'Config.time_value' do
-    test 'normal case' do
-      assert_equal(10, Config.time_value("10s"))
-      assert_equal(10, Config.time_value("10sec"))
-      assert_equal(120, Config.time_value("2m"))
-      assert_equal(10800, Config.time_value("3h"))
-      assert_equal(345600, Config.time_value("4d"))
-    end
-
-    test 'not assumed case' do
-      assert_equal(4.0, Config.time_value(4))
-      assert_equal(0.4, Config.time_value(0.4))
-      assert_equal(0.0, Config.time_value("hoge"))
-      assert_equal(0.0, Config.time_value(""))
-      assert_equal(0.0, Config.time_value(nil))
-    end
-  end
-
-  sub_test_case 'Config.bool_value' do
-    test 'normal case' do
-      assert_true Config.bool_value("true")
-      assert_true Config.bool_value("yes")
-      assert_true Config.bool_value("")
-      assert_false Config.bool_value("false")
-      assert_false Config.bool_value("no")
-    end
-
-    test 'not assumed case' do
-      assert_true Config.bool_value(true)
-      assert_false Config.bool_value(false)
-      assert_nil Config.bool_value("hoge")
-      assert_nil Config.bool_value(nil)
-      assert_nil Config.bool_value(10)
-    end
-  end
-end

data/test/plugin/test_in_dummy.rb

@@ -1,95 +0,0 @@
-require_relative '../helper'
-require 'fluent/test'
-
-class DummyTest < Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-  end
-
-  def create_driver(conf)
-    Fluent::Test::InputTestDriver.new(Fluent::DummyInput).configure(conf)
-  end
-
-  sub_test_case 'configure' do
-    test 'required parameters' do
-      assert_raise_message("'tag' parameter is required") do
-        create_driver('')
-      end
-    end
-
-    test 'tag' do
-      d = create_driver(%[
-        tag dummy
-      ])
-      assert_equal "dummy", d.instance.tag
-    end
-
-    config = %[
-      tag dummy
-    ]
-
-    test 'auto_increment_key' do
-      d = create_driver(config + %[
-        auto_increment_key id
-      ])
-      assert_equal "id", d.instance.auto_increment_key
-    end
-
-    test 'rate' do
-      d = create_driver(config + %[
-        rate 10
-      ])
-      assert_equal 10, d.instance.rate
-    end
-
-    test 'dummy' do
-      # hash is okay
-      d = create_driver(config + %[dummy {"foo":"bar"}])
-      assert_equal [{"foo"=>"bar"}], d.instance.dummy
-
-      # array of hash is okay
-      d = create_driver(config + %[dummy [{"foo":"bar"}]])
-      assert_equal [{"foo"=>"bar"}], d.instance.dummy
-
-      assert_raise_message(/JSON::ParserError|got incomplete JSON/) do
-        create_driver(config + %[dummy "foo"])
-      end
-
-      assert_raise_message(/is not a hash/) do
-        create_driver(config + %[dummy ["foo"]])
-      end
-    end
-  end
-
-  sub_test_case "emit" do
-    config = %[
-      tag dummy
-      rate 10
-      dummy {"foo":"bar"}
-    ]
-
-    test 'simple' do
-      d = create_driver(config)
-      d.run {
-        # d.run sleeps 0.5 sec
-      }
-      emits = d.emits
-      emits.each do |tag, time, record|
-        assert_equal("dummy", tag)
-        assert_equal({"foo"=>"bar"}, record)
-      end
-    end
-
-    test 'with auto_increment_key' do
-      d = create_driver(config + %[auto_increment_key id])
-      d.run {
-        # d.run sleeps 0.5 sec
-      }
-      emits = d.emits
-      emits.each_with_index do |(tag, time, record), i|
-        assert_equal("dummy", tag)
-        assert_equal({"foo"=>"bar", "id"=>i}, record)
-      end
-    end
-  end
-end

data/test/test_event.rb

@@ -1,168 +0,0 @@
-require_relative 'helper'
-require 'fluent/test'
-require 'fluent/event'
-
-module EventTest
-  class OneEventStreamTest < ::Test::Unit::TestCase
-    include Fluent
-
-    def setup
-      @time = Engine.now
-      @record = {'k' => 'v', 'n' => 1}
-      @es = OneEventStream.new(@time, @record)
-    end
-
-    test 'repeatable?' do
-      assert_true @es.repeatable?
-    end
-
-    test 'dup' do
-      dupped = @es.dup
-      assert_kind_of OneEventStream, dupped
-      assert_not_equal @es.object_id, dupped.object_id
-    end
-
-    test 'each' do
-      @es.each { |time, record|
-        assert_equal @time, time
-        assert_equal @record, record
-      }
-    end
-
-    test 'to_msgpack_stream' do
-      stream = @es.to_msgpack_stream
-      MessagePack::Unpacker.new.feed_each(stream) { |time, record|
-        assert_equal @time, time
-        assert_equal @record, record
-      }
-    end
-  end
-
-  class ArrayEventStreamTest < ::Test::Unit::TestCase
-    include Fluent
-
-    def setup
-      @times = [Engine.now, Engine.now + 1]
-      @records = [{'k' => 'v1', 'n' => 1}, {'k' => 'v2', 'n' => 2}]
-      @es = ArrayEventStream.new(@times.zip(@records))
-    end
-
-    test 'repeatable?' do
-      assert_true @es.repeatable?
-    end
-
-    test 'dup' do
-      dupped = @es.dup
-      assert_kind_of ArrayEventStream, dupped
-      assert_not_equal @es.object_id, dupped.object_id
-    end
-
-    test 'empty?' do
-      assert_not_empty @es
-      assert_true ArrayEventStream.new([]).empty?
-    end
-
-    test 'each' do
-      i = 0
-      @es.each { |time, record|
-        assert_equal @times[i], time
-        assert_equal @records[i], record
-        i += 1
-      }
-    end
-
-    test 'to_msgpack_stream' do
-      i = 0
-      stream = @es.to_msgpack_stream
-      MessagePack::Unpacker.new.feed_each(stream) { |time, record|
-        assert_equal @times[i], time
-        assert_equal @records[i], record
-        i += 1
-      }
-    end
-  end
-
-  class MultiEventStreamTest < ::Test::Unit::TestCase
-    include Fluent
-
-    def setup
-      @times = [Engine.now, Engine.now + 1]
-      @records = [{'k' => 'v1', 'n' => 1}, {'k' => 'v2', 'n' => 2}]
-      @es = MultiEventStream.new
-      @times.zip(@records).each { |time, record|
-        @es.add(time, record)
-      }
-    end
-
-    test 'repeatable?' do
-      assert_true @es.repeatable?
-    end
-
-    test 'dup' do
-      dupped = @es.dup
-      assert_kind_of MultiEventStream, dupped
-      assert_not_equal @es.object_id, dupped.object_id
-    end
-
-    test 'empty?' do
-      assert_not_empty @es
-      assert_true MultiEventStream.new.empty?
-    end
-
-    test 'each' do
-      i = 0
-      @es.each { |time, record|
-        assert_equal @times[i], time
-        assert_equal @records[i], record
-        i += 1
-      }
-    end
-
-    test 'to_msgpack_stream' do
-      i = 0
-      stream = @es.to_msgpack_stream
-      MessagePack::Unpacker.new.feed_each(stream) { |time, record|
-        assert_equal @times[i], time
-        assert_equal @records[i], record
-        i += 1
-      }
-    end
-  end
-
-  class MessagePackEventStreamTest < ::Test::Unit::TestCase
-    include Fluent
-
-    def setup
-      out = ''.force_encoding('ASCII-8BIT')
-      @times = [Engine.now, Engine.now + 1]
-      @records = [{'k' => 'v1', 'n' => 1}, {'k' => 'v2', 'n' => 2}]
-      @times.zip(@records).each { |time, record|
-        out << MessagePack.pack([time, record])
-      }
-      @es = MessagePackEventStream.new(out)
-    end
-
-    test 'repeatable?' do
-      assert_true @es.repeatable?
-    end
-
-    test 'each' do
-      i = 0
-      @es.each { |time, record|
-        assert_equal @times[i], time
-        assert_equal @records[i], record
-        i += 1
-      }
-    end
-
-    test 'to_msgpack_stream' do
-      i = 0
-      stream = @es.to_msgpack_stream
-      MessagePack::Unpacker.new.feed_each(stream) { |time, record|
-        assert_equal @times[i], time
-        assert_equal @records[i], record
-        i += 1
-      }
-    end
-  end
-end