fluentd 0.14.4-x64-mingw32

data/test/plugin/test_in_tcp.rb

@@ -0,0 +1,102 @@
+require_relative '../helper'
+require 'fluent/test'
+require 'fluent/plugin/in_tcp'
+
+class TcpInputTest < Test::Unit::TestCase
+  class << self
+    def startup
+      socket_manager_path = ServerEngine::SocketManager::Server.generate_path
+      @server = ServerEngine::SocketManager::Server.open(socket_manager_path)
+      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
+    end
+
+    def shutdown
+      @server.close
+    end
+  end
+
+  def setup
+    Fluent::Test.setup
+  end
+
+  PORT = unused_port
+  BASE_CONFIG = %[
+    port #{PORT}
+    tag tcp
+  ]
+  CONFIG = BASE_CONFIG + %[
+    bind 127.0.0.1
+    format none
+  ]
+  IPv6_CONFIG = BASE_CONFIG + %[
+    bind ::1
+    format none
+  ]
+
+  def create_driver(conf)
+    Fluent::Test::InputTestDriver.new(Fluent::TcpInput).configure(conf)
+  end
+
+  def test_configure
+    configs = {'127.0.0.1' => CONFIG}
+    configs.merge!('::1' => IPv6_CONFIG) if ipv6_enabled?
+
+    configs.each_pair { |k, v|
+      d = create_driver(v)
+      assert_equal PORT, d.instance.port
+      assert_equal k, d.instance.bind
+      assert_equal "\n", d.instance.delimiter
+    }
+  end
+
+  {
+    'none' => [
+      {'msg' => "tcptest1\n", 'expected' => 'tcptest1'},
+      {'msg' => "tcptest2\n", 'expected' => 'tcptest2'},
+    ],
+    'json' => [
+      {'msg' => {'k' => 123, 'message' => 'tcptest1'}.to_json + "\n", 'expected' => 'tcptest1'},
+      {'msg' => {'k' => 'tcptest2', 'message' => 456}.to_json + "\n", 'expected' => 456},
+    ]
+  }.each { |format, test_cases|
+    define_method("test_msg_size_#{format}") do
+      d = create_driver(BASE_CONFIG + "format #{format}")
+      tests = test_cases
+
+      d.run do
+        tests.each {|test|
+          TCPSocket.open('127.0.0.1', PORT) do |s|
+            s.send(test['msg'], 0)
+          end
+        }
+        sleep 1
+      end
+
+      compare_test_result(d.emits, tests)
+    end
+
+    define_method("test_msg_size_with_same_connection_#{format}") do
+      d = create_driver(BASE_CONFIG + "format #{format}")
+      tests = test_cases
+
+      d.run do
+        TCPSocket.open('127.0.0.1', PORT) do |s|
+          tests.each {|test|
+            s.send(test['msg'], 0)
+          }
+        end
+        sleep 1
+      end
+
+      compare_test_result(d.emits, tests)
+    end
+  }
+
+  def compare_test_result(emits, tests)
+    assert_equal(2, emits.size)
+    emits.each_index {|i|
+      assert_equal(tests[i]['expected'], emits[i][2]['message'])
+      assert(emits[i][1].is_a?(Fluent::EventTime))
+    }
+  end
+end

data/test/plugin/test_in_udp.rb

@@ -0,0 +1,121 @@
+require_relative '../helper'
+require 'fluent/test'
+require 'fluent/plugin/in_udp'
+
+class UdpInputTest < Test::Unit::TestCase
+  class << self
+    def startup
+      socket_manager_path = ServerEngine::SocketManager::Server.generate_path
+      @server = ServerEngine::SocketManager::Server.open(socket_manager_path)
+      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
+    end
+
+    def shutdown
+      @server.close
+    end
+  end
+
+  def setup
+    Fluent::Test.setup
+  end
+
+  PORT = unused_port
+  BASE_CONFIG = %[
+    port #{PORT}
+    tag udp
+  ]
+  CONFIG = BASE_CONFIG + %!
+    bind 127.0.0.1
+    format /^\\[(?<time>[^\\]]*)\\] (?<message>.*)/
+  !
+  IPv6_CONFIG = BASE_CONFIG + %!
+    bind ::1
+    format /^\\[(?<time>[^\\]]*)\\] (?<message>.*)/
+  !
+
+  def create_driver(conf)
+    Fluent::Test::InputTestDriver.new(Fluent::UdpInput).configure(conf)
+  end
+
+  def test_configure
+    configs = {'127.0.0.1' => CONFIG}
+    configs.merge!('::1' => IPv6_CONFIG) if ipv6_enabled?
+
+    configs.each_pair { |k, v|
+      d = create_driver(v)
+      assert_equal PORT, d.instance.port
+      assert_equal k, d.instance.bind
+      assert_equal 4096, d.instance.body_size_limit
+    }
+  end
+
+  def test_time_format
+    configs = {'127.0.0.1' => CONFIG}
+    configs.merge!('::1' => IPv6_CONFIG) if ipv6_enabled?
+
+    configs.each_pair { |k, v|
+      d = create_driver(v)
+
+      tests = [
+        {'msg' => '[Sep 11 00:00:00] localhost logger: foo', 'expected' => Fluent::EventTime.from_time(Time.strptime('Sep 11 00:00:00', '%b %d %H:%M:%S'))},
+        {'msg' => '[Sep  1 00:00:00] localhost logger: foo', 'expected' => Fluent::EventTime.from_time(Time.strptime('Sep  1 00:00:00', '%b  %d %H:%M:%S'))},
+      ]
+
+      d.run do
+        u = Fluent::SocketUtil.create_udp_socket(k)
+        u.connect(k, PORT)
+        tests.each {|test|
+          u.send(test['msg'], 0)
+        }
+        u.close
+        sleep 1
+      end
+
+      emits = d.emits
+      emits.each_index {|i|
+        assert_equal_event_time(tests[i]['expected'], emits[i][1])
+      }
+    }
+
+  end
+
+  {
+    'none' => [
+      {'msg' => "tcptest1\n", 'expected' => 'tcptest1'},
+      {'msg' => "tcptest2\n", 'expected' => 'tcptest2'},
+    ],
+    'json' => [
+      {'msg' => {'k' => 123, 'message' => 'tcptest1'}.to_json + "\n", 'expected' => 'tcptest1'},
+      {'msg' => {'k' => 'tcptest2', 'message' => 456}.to_json + "\n", 'expected' => 456},
+    ],
+    '/^\\[(?<time>[^\\]]*)\\] (?<message>.*)/' => [
+      {'msg' => '[Sep 10 00:00:00] localhost: ' + 'x' * 100 + "\n", 'expected' => 'localhost: ' + 'x' * 100},
+      {'msg' => '[Sep 10 00:00:00] localhost: ' + 'x' * 1024 + "\n", 'expected' => 'localhost: ' + 'x' * 1024},
+    ]
+  }.each { |format, test_cases|
+    define_method("test_msg_size_#{format[0] == '/' ? 'regexp' : format}") do
+      d = create_driver(BASE_CONFIG + "format #{format}")
+      tests = test_cases
+
+      d.run do
+        u = UDPSocket.new
+        u.connect('127.0.0.1', PORT)
+        tests.each { |test|
+          u.send(test['msg'], 0)
+        }
+        u.close
+        sleep 1
+      end
+
+      compare_test_result(d.emits, tests)
+    end
+  }
+
+  def compare_test_result(emits, tests)
+    assert_equal(2, emits.size)
+    emits.each_index {|i|
+      assert_equal(tests[i]['expected'], emits[i][2]['message'])
+      assert(emits[i][1].is_a?(Fluent::EventTime))
+    }
+  end
+end

data/test/plugin/test_in_unix.rb

@@ -0,0 +1,126 @@
+require_relative '../helper'
+require 'fluent/test'
+require 'fluent/plugin/in_unix'
+
+module StreamInputTest
+  def setup
+    Fluent::Test.setup
+  end
+
+  def test_time
+    d = create_driver
+
+    time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
+    Fluent::Engine.now = time
+
+    d.expect_emit "tag1", time, {"a"=>1}
+    d.expect_emit "tag2", time, {"a"=>2}
+
+    d.run do
+      d.expected_emits.each {|tag,_time,record|
+        send_data Fluent::Engine.msgpack_factory.packer.write([tag, 0, record]).to_s
+      }
+    end
+  end
+
+  def test_message
+    d = create_driver
+
+    time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
+
+    d.expect_emit "tag1", time, {"a"=>1}
+    d.expect_emit "tag2", time, {"a"=>2}
+
+    d.run do
+      d.expected_emits.each {|tag,_time,record|
+        send_data Fluent::Engine.msgpack_factory.packer.write([tag, _time, record]).to_s
+      }
+    end
+  end
+
+  def test_forward
+    d = create_driver
+
+    time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
+
+    d.expect_emit "tag1", time, {"a"=>1}
+    d.expect_emit "tag1", time, {"a"=>2}
+
+    d.run do
+      entries = []
+      d.expected_emits.each {|tag,_time,record|
+        entries << [_time, record]
+      }
+      send_data Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
+    end
+  end
+
+  def test_packed_forward
+    d = create_driver
+
+    time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
+
+    d.expect_emit "tag1", time, {"a"=>1}
+    d.expect_emit "tag1", time, {"a"=>2}
+
+    d.run do
+      entries = ''
+      d.expected_emits.each {|tag,_time,record|
+        Fluent::Engine.msgpack_factory.packer(entries).write([_time, record]).flush
+      }
+      send_data Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
+    end
+  end
+
+  def test_message_json
+    d = create_driver
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+
+    d.expect_emit "tag1", time, {"a"=>1}
+    d.expect_emit "tag2", time, {"a"=>2}
+
+    d.run do
+      d.expected_emits.each {|tag,_time,record|
+        send_data [tag, time, record].to_json
+      }
+    end
+  end
+
+  def create_driver(klass, conf)
+    Fluent::Test::InputTestDriver.new(klass).configure(conf)
+  end
+
+  def send_data(data)
+    io = connect
+    begin
+      io.write data
+    ensure
+      io.close
+    end
+  end
+end
+
+class UnixInputTest < Test::Unit::TestCase
+  include StreamInputTest
+
+  TMP_DIR = File.dirname(__FILE__) + "/../tmp/in_unix#{ENV['TEST_ENV_NUMBER']}"
+  CONFIG = %[
+    path #{TMP_DIR}/unix
+    backlog 1000
+  ]
+
+  def create_driver(conf=CONFIG)
+    super(Fluent::UnixInput, conf)
+  end
+
+  def test_configure
+    d = create_driver
+    assert_equal "#{TMP_DIR}/unix", d.instance.path
+    assert_equal 1000, d.instance.backlog
+  end
+
+  def connect
+    UNIXSocket.new("#{TMP_DIR}/unix")
+  end
+end unless Fluent.windows?

data/test/plugin/test_input.rb

@@ -0,0 +1,122 @@
+require_relative '../helper'
+require 'fluent/plugin/input'
+require 'flexmock/test_unit'
+
+module FluentPluginInputTest
+  class DummyPlugin < Fluent::Plugin::Input
+  end
+end
+
+class InputTest < Test::Unit::TestCase
+  setup do
+    Fluent::Test.setup
+    @p = FluentPluginInputTest::DummyPlugin.new
+  end
+
+  test 'has healthy lifecycle' do
+    assert !@p.configured?
+    @p.configure(config_element())
+    assert @p.configured?
+
+    assert !@p.started?
+    @p.start
+    assert @p.start
+
+    assert !@p.stopped?
+    @p.stop
+    assert @p.stopped?
+
+    assert !@p.before_shutdown?
+    @p.before_shutdown
+    assert @p.before_shutdown?
+
+    assert !@p.shutdown?
+    @p.shutdown
+    assert @p.shutdown?
+
+    assert !@p.after_shutdown?
+    @p.after_shutdown
+    assert @p.after_shutdown?
+
+    assert !@p.closed?
+    @p.close
+    assert @p.closed?
+
+    assert !@p.terminated?
+    @p.terminate
+    assert @p.terminated?
+  end
+
+  test 'has plugin_id automatically generated' do
+    assert @p.respond_to?(:plugin_id_configured?)
+    assert @p.respond_to?(:plugin_id)
+
+    @p.configure(config_element())
+
+    assert !@p.plugin_id_configured?
+    assert @p.plugin_id
+    assert{ @p.plugin_id != 'mytest' }
+  end
+
+  test 'has plugin_id manually configured' do
+    @p.configure(config_element('ROOT', '', {'@id' => 'mytest'}))
+    assert @p.plugin_id_configured?
+    assert_equal 'mytest', @p.plugin_id
+  end
+
+  test 'has plugin logger' do
+    assert @p.respond_to?(:log)
+    assert @p.log
+
+    # default logger
+    original_logger = @p.log
+
+    @p.configure(config_element('ROOT', '', {'@log_level' => 'debug'}))
+
+    assert{ @p.log.object_id != original_logger.object_id }
+    assert_equal Fluent::Log::LEVEL_DEBUG, @p.log.level
+  end
+
+  test 'can load plugin helpers' do
+    assert_nothing_raised do
+      class FluentPluginInputTest::DummyPlugin2 < Fluent::Plugin::Input
+        helpers :storage
+      end
+    end
+  end
+
+  test 'has router and can emit into it' do
+    assert @p.has_router?
+
+    @p.configure(config_element())
+    assert @p.router
+
+    DummyRouter = Struct.new(:emits) do
+      def emit(tag, es)
+        self.emits << [tag, es]
+      end
+    end
+    @p.router = DummyRouter.new([])
+    @p.router.emit('mytag', [])
+    @p.router.emit('mytag.testing', ['it is not es, but no problem for tests'])
+
+    assert_equal ['mytag', []], @p.router.emits[0]
+    assert_equal ['mytag.testing', ['it is not es, but no problem for tests']], @p.router.emits[1]
+  end
+
+  test 'has router for specified label if configured' do
+    @p.configure(config_element())
+    original_router = @p.router
+
+    router_mock = flexmock('mytest')
+    router_mock.should_receive(:emit).once.with('mytag.testing', ['for mock'])
+    label_mock = flexmock('mylabel')
+    label_mock.should_receive(:event_router).once.and_return(router_mock)
+    Fluent::Engine.root_agent.labels['@mytest'] = label_mock
+
+    @p.configure(config_element('ROOT', '', {'@label' => '@mytest'}))
+    assert{ @p.router.object_id != original_router.object_id }
+
+    @p.router.emit('mytag.testing', ['for mock'])
+  end
+end