fluentd 0.10.36 → 0.10.37

data/lib/fluent/test/base.rb

@@ -16,49 +16,45 @@
 #    limitations under the License.
 #
 module Fluent
-module Test
-
-
-class TestDriver
-  include ::Test::Unit::Assertions
-
-  def initialize(klass, &block)
-    if klass.is_a?(Class)
-      if block
-        klass = klass.dup
-        klass.module_eval(&block)
+  module Test
+    class TestDriver
+      include ::Test::Unit::Assertions
+
+      def initialize(klass, &block)
+        if klass.is_a?(Class)
+          if block
+            klass = klass.dup
+            klass.module_eval(&block)
+          end
+          @instance = klass.new
+        else
+          @instance = klass
+        end
+        @config = Config.new
       end
-      @instance = klass.new
-    else
-      @instance = klass
-    end
-    @config = Config.new
-  end
 
-  attr_reader :instance, :config
+      attr_reader :instance, :config
 
-  def configure(str)
-    if str.is_a?(Fluent::Config::Element)
-      @config = str
-    else
-      @config = Config.parse(str, "(test)")
-    end
-    @instance.configure(@config)
-    self
-  end
+      def configure(str)
+        if str.is_a?(Fluent::Config::Element)
+          @config = str
+        else
+          @config = Config.parse(str, "(test)")
+        end
+        @instance.configure(@config)
+        self
+      end
 
-  def run(&block)
-    @instance.start
-    begin
-      # wait until thread starts
-      10.times { sleep 0.05 }
-      return yield
-    ensure
-      @instance.shutdown
+      def run(&block)
+        @instance.start
+        begin
+          # wait until thread starts
+          10.times { sleep 0.05 }
+          return yield
+        ensure
+          @instance.shutdown
+        end
+      end
     end
   end
 end
-
-
-end
-end

data/lib/fluent/test/input_test.rb

@@ -16,84 +16,89 @@
 #    limitations under the License.
 #
 module Fluent
-module Test
+  require 'fluent/plugin/buf_file'
 
-
-class InputTestDriver < TestDriver
-  def initialize(klass, &block)
-    super(klass, &block)
-    @emit_streams = []
-    @expects = nil
-  end
-
-  def expect_emit(tag, time, record)
-    (@expects ||= []) << [tag, time, record]
-    self
-  end
-
-  def expected_emits
-    @expects ||= []
+  class FileBuffer
+    def self.clear_buffer_paths
+      @@buffer_paths = {}
+    end
   end
 
-  attr_reader :emit_streams
+  module Test
+    class InputTestDriver < TestDriver
+      def initialize(klass, &block)
+        FileBuffer.clear_buffer_paths
+        super(klass, &block)
+        @emit_streams = []
+        @expects = nil
+      end
 
-  def emits
-    all = []
-    @emit_streams.each {|tag,events|
-      events.each {|time,record|
-        all << [tag, time, record]
-      }
-    }
-    all
-  end
+      def expect_emit(tag, time, record)
+        (@expects ||= []) << [tag, time, record]
+        self
+      end
 
-  def events
-    all = []
-    @emit_streams.each {|tag,events|
-      all.concat events
-    }
-    all
-  end
+      def expected_emits
+        @expects ||= []
+      end
 
-  def records
-    all = []
-    @emit_streams.each {|tag,events|
-      events.each {|time,record|
-        all << record
-      }
-    }
-    all
-  end
+      attr_reader :emit_streams
 
-  def run(&block)
-    m = method(:emit_stream)
-    super {
-      Engine.define_singleton_method(:emit_stream) {|tag,es|
-        m.call(tag, es)
-      }
+      def emits
+        all = []
+        @emit_streams.each {|tag,events|
+          events.each {|time,record|
+            all << [tag, time, record]
+          }
+        }
+        all
+      end
 
-      block.call if block
+      def events
+        all = []
+        @emit_streams.each {|tag,events|
+          all.concat events
+        }
+        all
+      end
 
-      if @expects
-        i = 0
+      def records
+        all = []
         @emit_streams.each {|tag,events|
           events.each {|time,record|
-            assert_equal(@expects[i], [tag, time, record])
-            i += 1
+            all << record
           }
         }
-        assert_equal @expects.length, i
+        all
       end
-    }
-    self
-  end
 
-  private
-  def emit_stream(tag, es)
-    @emit_streams << [tag, es.to_a]
-  end
-end
+      def run(&block)
+        m = method(:emit_stream)
+        super {
+          Engine.define_singleton_method(:emit_stream) {|tag,es|
+            m.call(tag, es)
+          }
 
+          block.call if block
 
-end
+          if @expects
+            i = 0
+            @emit_streams.each {|tag,events|
+              events.each {|time,record|
+                assert_equal(@expects[i], [tag, time, record])
+                i += 1
+              }
+            }
+            assert_equal @expects.length, i
+          end
+        }
+        self
+      end
+
+      private
+      def emit_stream(tag, es)
+        @emit_streams << [tag, es.to_a]
+      end
+    end
+  end
 end

data/lib/fluent/test/output_test.rb

@@ -16,131 +16,128 @@
 #    limitations under the License.
 #
 module Fluent
-module Test
+  module Test
+    class TestOutputChain
+      def initialize
+        @called = 0
+      end
 
+      def next
+        @called += 1
+      end
 
-class TestOutputChain
-  def initialize
-    @called = 0
-  end
+      attr_reader :called
+    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
 
-class OutputTestDriver < InputTestDriver
-  def initialize(klass, tag='test', &block)
-    super(klass, &block)
-    @tag = tag
-  end
+      attr_accessor :tag
 
-  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
 
-  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
 
-class BufferedOutputTestDriver < InputTestDriver
-  def initialize(klass, tag='test', &block)
-    super(klass, &block)
-    @entries = []
-    @expected_buffer = nil
-    @tag = tag
-  end
+      attr_accessor :tag
 
-  attr_accessor :tag
+      def emit(record, time=Time.now)
+        @entries << [time.to_i, record]
+        self
+      end
 
-  def emit(record, time=Time.now)
-    @entries << [time.to_i, record]
-    self
-  end
+      def expect_format(str)
+        (@expected_buffer ||= '') << str
+      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)
 
-  def run(&block)
-    result = nil
-    super {
-      es = ArrayEventStream.new(@entries)
-      buffer = @instance.format_stream(@tag, es)
+          block.call if block
 
-      block.call if block
+          if @expected_buffer
+            assert_equal(@expected_buffer, buffer)
+          end
 
-      if @expected_buffer
-        assert_equal(@expected_buffer, buffer)
+          chunk = MemoryBufferChunk.new('', buffer)
+          result = @instance.write(chunk)
+        }
+        result
+      end
+    end
+
+    class TimeSlicedOutputTestDriver < InputTestDriver
+      def initialize(klass, tag='test', &block)
+        super(klass, &block)
+        @entries = {}
+        @expected_buffer = nil
+        @tag = tag
       end
 
-      chunk = MemoryBufferChunk.new('', buffer)
-      result = @instance.write(chunk)
-    }
-    result
-  end
-end
-
-class TimeSlicedOutputTestDriver < InputTestDriver
-  def initialize(klass, tag='test', &block)
-    super(klass, &block)
-    @entries = {}
-    @expected_buffer = nil
-    @tag = tag
-  end
-
-  attr_accessor :tag
+      attr_accessor :tag
 
-  def emit(record, time=Time.now)
-    slicer = @instance.instance_eval{@time_slicer}
-    key = slicer.call(time.to_i)
-    @entries[key] = [] unless @entries.has_key?(key)
-    @entries[key] << [time.to_i, record]
-    self
-  end
+      def emit(record, time=Time.now)
+        slicer = @instance.instance_eval{@time_slicer}
+        key = slicer.call(time.to_i)
+        @entries[key] = [] unless @entries.has_key?(key)
+        @entries[key] << [time.to_i, record]
+        self
+      end
 
-  def expect_format(str)
-    (@expected_buffer ||= '') << str
-  end
+      def expect_format(str)
+        (@expected_buffer ||= '') << str
+      end
 
-  def run(&block)
-    result = []
-    super {
-      buffer = ''
-      @entries.keys.each {|key|
-        es = ArrayEventStream.new(@entries[key])
-        @instance.emit(@tag, es, NullOutputChain.instance)
-        buffer << @instance.format_stream(@tag, es)
-      }
+      def run(&block)
+        result = []
+        super {
+          buffer = ''
+          @entries.keys.each {|key|
+            es = ArrayEventStream.new(@entries[key])
+            @instance.emit(@tag, es, NullOutputChain.instance)
+            buffer << @instance.format_stream(@tag, es)
+          }
 
-      block.call if block
+          block.call if block
 
-      if @expected_buffer
-        assert_equal(@expected_buffer, buffer)
-      end
+          if @expected_buffer
+            assert_equal(@expected_buffer, buffer)
+          end
 
-      chunks = @instance.instance_eval {
-        @buffer.instance_eval {
-          chunks = []
-          @map.keys.each {|key|
-            chunks.push(@map.delete(key))
+          chunks = @instance.instance_eval {
+            @buffer.instance_eval {
+              chunks = []
+              @map.keys.each {|key|
+                chunks.push(@map.delete(key))
+              }
+              chunks
+            }
+          }
+          chunks.each { |chunk|
+            result.push(@instance.write(chunk))
           }
-          chunks
         }
-      }
-      chunks.each { |chunk|
-        result.push(@instance.write(chunk))
-      }
-    }
-    result
+        result
+      end
+    end
   end
 end
-
-end
-end