fluentd 0.10.0

data/lib/fluent/test/output_test.rb

@@ -0,0 +1,93 @@
+#
+# Fluent
+#
+# Copyright (C) 2011 FURUHASHI Sadayuki
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module Fluent
+module Test
+
+
+class TestOutputChain
+  def initialize
+    @called = 0
+  end
+
+  def next
+    @called += 1
+  end
+
+  attr_reader :called
+end
+
+
+class OutputTestDriver < InputTestDriver
+  def initialize(klass, tag='test', &block)
+    super(klass, &block)
+    @tag = tag
+  end
+
+  attr_accessor :tag
+
+  def emit(record, time=Time.now)
+    es = OneEventStream.new(time.to_i, record)
+    chain = TestOutputChain.new
+    @instance.emit(@tag, es, chain)
+    assert_equal 1, chain.called
+  end
+end
+
+
+class BufferedOutputTestDriver < InputTestDriver
+  def initialize(klass, tag='test', &block)
+    super(klass, &block)
+    @entries = []
+    @expected_buffer = nil
+    @tag = tag
+  end
+
+  attr_accessor :tag
+
+  def emit(record, time=Time.now)
+    @entries << [time.to_i, record]
+    self
+  end
+
+  def expect_format(str)
+    (@expected_buffer ||= '') << str
+  end
+
+  def run(&block)
+    result = nil
+    super {
+      es = ArrayEventStream.new(@entries)
+      buffer = @instance.format_stream(@tag, es)
+
+      block.call if block
+
+      if @expected_buffer
+        assert_equal(@expected_buffer, buffer)
+      end
+
+      chunk = MemoryBufferChunk.new('', buffer)
+      result = @instance.write(chunk)
+    }
+    result
+  end
+end
+
+
+end
+end
+

data/lib/fluent/version.rb

@@ -0,0 +1,5 @@
+module Fluent
+
+VERSION = '0.10.0'
+
+end

data/test/helper.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+require 'fileutils'
+
+class Test::Unit::TestCase
+end
+

data/test/match.rb

@@ -0,0 +1,115 @@
+require File.dirname(__FILE__) + '/helper'
+
+require 'fluent/match'
+
+class MatchTest < Test::Unit::TestCase
+  include Fluent
+
+  def test_simple
+    assert_match('a', 'a')
+    assert_match('a.b', 'a.b')
+    assert_not_match('a', 'b')
+    assert_not_match('a.b', 'aab')
+  end
+
+  def test_wildcard
+    assert_match('a*', 'a')
+    assert_match('a*', 'ab')
+    assert_match('a*', 'abc')
+
+    assert_match('*a', 'a')
+    assert_match('*a', 'ba')
+    assert_match('*a', 'cba')
+
+    assert_match('*a*', 'a')
+    assert_match('*a*', 'ba')
+    assert_match('*a*', 'ac')
+    assert_match('*a*', 'bac')
+
+    assert_not_match('a*', 'a.b')
+    assert_not_match('a*', 'ab.c')
+    assert_not_match('a*', 'ba')
+    assert_not_match('*a', 'ab')
+
+    assert_match('a.*', 'a.b')
+    assert_match('a.*', 'a.c')
+    assert_not_match('a.*', 'ab')
+
+    assert_match('a.*.c', 'a.b.c')
+    assert_match('a.*.c', 'a.c.c')
+    assert_not_match('a.*.c', 'a.c')
+  end
+
+  def test_recursive_wildcard
+    assert_match('a.**', 'a')
+    assert_not_match('a.**', 'ab')
+    assert_not_match('a.**', 'abc')
+    assert_match('a.**', 'a.b')
+    assert_not_match('a.**', 'ab.c')
+    assert_not_match('a.**', 'ab.d.e')
+
+    assert_match('a**', 'a')
+    assert_match('a**', 'ab')
+    assert_match('a**', 'abc')
+    assert_match('a**', 'a.b')
+    assert_match('a**', 'ab.c')
+    assert_match('a**', 'ab.d.e')
+
+    assert_match('**.a', 'a')
+    assert_not_match('**.a', 'ba')
+    assert_not_match('**.a', 'c.ba')
+    assert_match('**.a', 'b.a')
+    assert_match('**.a', 'cb.a')
+    assert_match('**.a', 'd.e.a')
+
+    assert_match('**a', 'a')
+    assert_match('**a', 'ba')
+    assert_match('**a', 'c.ba')
+    assert_match('**a', 'b.a')
+    assert_match('**a', 'cb.a')
+    assert_match('**a', 'd.e.a')
+  end
+
+  def test_or
+    assert_match('a.{b,c}', 'a.b')
+    assert_match('a.{b,c}', 'a.c')
+    assert_not_match('a.{b,c}', 'a.d')
+
+    assert_match('a.{b,c}.**', 'a.b')
+    assert_match('a.{b,c}.**', 'a.c')
+    assert_not_match('a.{b,c}.**', 'a.d')
+    assert_not_match('a.{b,c}.**', 'a.cd')
+
+    assert_match('a.{b.**,c}', 'a.b')
+    assert_match('a.{b.**,c}', 'a.b.c')
+    assert_match('a.{b.**,c}', 'a.c')
+    assert_not_match('a.{b.**,c}', 'a.c.d')
+  end
+
+  #def test_character_class
+  #  assert_match('[a]', 'a')
+  #  assert_match('[ab]', 'a')
+  #  assert_match('[ab]', 'b')
+  #  assert_not_match('[ab]', 'c')
+  #
+  #  assert_match('[a-b]', 'a')
+  #  assert_match('[a-b]', 'a')
+  #  assert_match('[a-b]', 'b')
+  #  assert_not_match('[a-b]', 'c')
+  #
+  #  assert_match('[a-b0-9]', 'a')
+  #  assert_match('[a-b0-9]', '0')
+  #  assert_not_match('[a-b0-9]', 'c')
+  #end
+
+  def assert_match(pat, str)
+    m = GlobMatchPattern.new(pat)
+    assert_equal true, m.match(str)
+  end
+
+  def assert_not_match(pat, str)
+    m = GlobMatchPattern.new(pat)
+    assert_equal false, m.match(str)
+  end
+end
+

data/test/plugin/in_http.rb

@@ -0,0 +1,84 @@
+require 'fluent/test'
+require 'net/http'
+
+class HttpInputTest < Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  CONFIG = %[
+    port 9911
+    bind 127.0.0.1
+    body_size_limit 10m
+    keepalive_timeout 5
+  ]
+
+  def create_driver(conf=CONFIG)
+    Fluent::Test::InputTestDriver.new(Fluent::HttpInput).configure(conf)
+  end
+
+  def test_configure
+    d = create_driver
+    assert_equal 9911, d.instance.port
+    assert_equal '127.0.0.1', d.instance.bind
+    assert_equal 10*1024*1024, d.instance.body_size_limit
+    assert_equal 5, d.instance.keepalive_timeout
+  end
+
+  def test_time
+    d = create_driver
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    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|
+        res = post("/#{tag}", {"json"=>record.to_json})
+        assert_equal "200", res.code
+      }
+    end
+  end
+
+  def test_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|
+        res = post("/#{tag}", {"json"=>record.to_json, "time"=>time.to_s})
+        assert_equal "200", res.code
+      }
+    end
+  end
+
+  def test_msgpack
+    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|
+        res = post("/#{tag}", {"msgpack"=>record.to_msgpack, "time"=>time.to_s})
+        assert_equal "200", res.code
+      }
+    end
+  end
+
+  def post(path, params)
+    http = Net::HTTP.new("127.0.0.1", 9911)
+    req = Net::HTTP::Post.new(path, {})
+    req.set_form_data(params)
+    http.request(req)
+  end
+end
+

data/test/plugin/in_stream.rb

@@ -0,0 +1,136 @@
+require 'fluent/test'
+
+module StreamInputTest
+  def setup
+    Fluent::Test.setup
+  end
+
+  def test_time
+    d = create_driver
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    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 [tag, 0, record].to_msgpack
+      }
+      sleep 0.5
+    end
+  end
+
+  def test_message
+    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_msgpack
+      }
+      sleep 0.5
+    end
+  end
+
+  def test_forward
+    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 "tag1", time, {"a"=>2}
+
+    d.run do
+      entries = []
+      d.expected_emits.each {|tag,time,record|
+        entries << [time, record]
+      }
+      send_data ["tag1", entries].to_msgpack
+      sleep 0.5
+    end
+  end
+
+  def test_packed_forward
+    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 "tag1", time, {"a"=>2}
+
+    d.run do
+      entries = ''
+      d.expected_emits.each {|tag,time,record|
+        [time, record].to_msgpack(entries)
+      }
+      send_data ["tag1", entries].to_msgpack
+      sleep 0.5
+    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 TcpInputTest < Test::Unit::TestCase
+  include StreamInputTest
+
+  CONFIG = %[
+    port 13998
+    bind 127.0.0.1
+  ]
+
+  def create_driver(conf=CONFIG)
+    super(Fluent::TcpInput, conf)
+  end
+
+  def test_configure
+    d = create_driver
+    assert_equal 13998, d.instance.port
+    assert_equal '127.0.0.1', d.instance.bind
+  end
+
+  def connect
+    TCPSocket.new('127.0.0.1', 13998)
+  end
+end
+
+class UnixInputTest < Test::Unit::TestCase
+  include StreamInputTest
+
+  TMP_DIR = File.dirname(__FILE__) + "/../tmp"
+
+  CONFIG = %[
+    path #{TMP_DIR}/unix
+  ]
+
+  def create_driver(conf=CONFIG)
+    super(Fluent::UnixInput, conf)
+  end
+
+  def test_configure
+    d = create_driver
+    assert_equal "#{TMP_DIR}/unix", d.instance.path
+  end
+
+  def connect
+    UNIXSocket.new("#{TMP_DIR}/unix")
+  end
+end
+

data/test/plugin/out_copy.rb

@@ -0,0 +1,55 @@
+require 'fluent/test'
+
+class CopyOutputTest < Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  CONFIG = %[
+    <store>
+      type test
+      name c0
+    </store>
+    <store>
+      type test
+      name c1
+    </store>
+    <store>
+      type test
+      name c2
+    </store>
+  ]
+
+  def create_driver(conf = CONFIG)
+    Fluent::Test::OutputTestDriver.new(Fluent::CopyOutput).configure(conf)
+  end
+
+  def test_configure
+    d = create_driver
+
+    outputs = d.instance.outputs
+    assert_equal 3, outputs.size
+    assert_equal Fluent::TestOutput, outputs[0].class
+    assert_equal Fluent::TestOutput, outputs[1].class
+    assert_equal Fluent::TestOutput, outputs[2].class
+    assert_equal "c0", outputs[0].name
+    assert_equal "c1", outputs[1].name
+    assert_equal "c2", outputs[2].name
+  end
+
+  def test_emit
+    d = create_driver
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    d.emit({"a"=>1}, time)
+    d.emit({"a"=>2}, time)
+
+    d.instance.outputs.each {|o|
+      assert_equal [
+          [time, {"a"=>1}],
+          [time, {"a"=>2}],
+        ], o.events
+    }
+  end
+end
+