fluentd 0.14.4-x86-mingw32

data/lib/fluent/test/driver/parser.rb

@@ -0,0 +1,30 @@
+#
+# Fluentd
+#
+#    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.
+#
+
+require 'fluent/test/driver/base_owned'
+
+module Fluent
+  module Test
+    module Driver
+      class Parser < BaseOwned
+        def initialize(klass, **kwargs, &block)
+          super
+          @section_name = "parse"
+        end
+      end
+    end
+  end
+end

data/lib/fluent/test/driver/test_event_router.rb

@@ -0,0 +1,45 @@
+#
+# Fluentd
+#
+#    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.
+#
+
+require 'fluent/event'
+
+module Fluent
+  module Test
+    module Driver
+      class TestEventRouter
+        def initialize(driver)
+          @driver = driver
+        end
+
+        def emit(tag, time, record)
+          @driver.emit_event_stream(tag, OneEventStream.new(time, record))
+        end
+
+        def emit_array(tag, array)
+          @driver.emit_event_stream(tag, ArrayEventStream.new(array))
+        end
+
+        def emit_stream(tag, es)
+          @driver.emit_event_stream(tag, es)
+        end
+
+        def emit_error_event(tag, time, record, error)
+          @driver.emit_error_event(tag, time, record, error)
+        end
+      end
+    end
+  end
+end

data/lib/fluent/test/filter_test.rb

@@ -0,0 +1,77 @@
+#
+# Fluentd
+#
+#    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.
+#
+
+require 'fluent/test/base'
+require 'fluent/event'
+
+module Fluent
+  module Test
+    class FilterTestDriver < TestDriver
+      def initialize(klass, tag = 'filter.test', &block)
+        super(klass, &block)
+        @tag = tag
+        @events = {}
+        @filtered = MultiEventStream.new
+      end
+
+      attr_reader :filtered
+      attr_accessor :tag
+
+      def emit(record, time = Engine.now)
+        emit_with_tag(@tag, record, time)
+      end
+      alias_method :filter, :emit
+
+      def emit_with_tag(tag, record, time = Engine.now)
+        @events[tag] ||= MultiEventStream.new
+        @events[tag].add(time, record)
+      end
+      alias_method :filter_with_tag, :emit_with_tag
+
+      def filter_stream(es)
+        filter_stream_with_tag(@tag, es)
+      end
+
+      def filter_stream_with_tag(tag, es)
+        @events[tag] = es
+      end
+
+      def filtered_as_array
+        all = []
+        @filtered.each { |time, record|
+          all << [@tag, time, record]
+        }
+        all
+      end
+      alias_method :emits, :filtered_as_array # emits is for consistent with other drivers
+
+      # Almost filters don't use threads so default is 0. It reduces test time.
+      def run(num_waits = 0, &block)
+        super(num_waits) {
+          block.call if block
+
+          @events.each { |tag, es|
+            processed = @instance.filter_stream(tag, es)
+            processed.each { |time, record|
+              @filtered.add(time, record)
+            }
+          }
+        }
+        self
+      end
+    end
+  end
+end

data/lib/fluent/test/formatter_test.rb

@@ -0,0 +1,65 @@
+#
+# Fluentd
+#
+#    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.
+#
+
+require 'fluent/formatter'
+require 'fluent/config'
+require 'fluent/plugin'
+
+module Fluent
+  module Test
+    class FormatterTestDriver
+      def initialize(klass_or_str, proc=nil, &block)
+        if klass_or_str.is_a?(Class)
+          if block
+            # Create new class for test w/ overwritten methods
+            #   klass.dup is worse because its ancestors does NOT include original class name
+            klass_name = klass_or_str.name
+            klass_or_str = Class.new(klass_or_str)
+            klass_or_str.define_singleton_method("name") { klass_name }
+            klass_or_str.module_eval(&block)
+          end
+          @instance = klass_or_str.new
+        elsif klass_or_str.is_a?(String)
+          @instance = Fluent::Plugin.new_formatter(klass_or_str)
+        else
+          @instance = klass_or_str
+        end
+        @config = Config.new
+      end
+
+      attr_reader :instance, :config
+
+      def configure(conf)
+        case conf
+        when Fluent::Config::Element
+          @config = conf
+        when String
+          @config = Config.parse(conf, 'fluent.conf')
+        when Hash
+          @config = Config::Element.new('ROOT', '', conf, [])
+        else
+          raise "Unknown type... #{conf}"
+        end
+        @instance.configure(@config)
+        self
+      end
+
+      def format(tag, time, record)
+        @instance.format(tag, time, record)
+      end
+    end
+  end
+end

data/lib/fluent/test/helpers.rb

@@ -0,0 +1,79 @@
+#
+# Fluentd
+#
+#    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.
+#
+
+require 'fluent/config/element'
+require 'fluent/msgpack_factory'
+require 'fluent/time'
+
+module Fluent
+  module Test
+    module Helpers
+      def config_element(name = 'test', argument = '', params = {}, elements = [])
+        Fluent::Config::Element.new(name, argument, params, elements)
+      end
+
+      def event_time(str=nil, format: nil)
+        if str
+          if format
+            Fluent::EventTime.from_time(Time.strptime(str, format))
+          else
+            Fluent::EventTime.parse(str)
+          end
+        else
+          Fluent::EventTime.now
+        end
+      end
+
+      def time2str(time, localtime: false, format: nil)
+        if format
+          if localtime
+            Time.at(time).strftime(format)
+          else
+            Time.at(time).utc.strftime(format)
+          end
+        else
+          if localtime
+            Time.at(time).iso8601
+          else
+            Time.at(time).utc.iso8601
+          end
+        end
+      end
+
+      def msgpack(type)
+        case type
+        when :factory
+          Fluent::MessagePackFactory.factory
+        when :packer
+          Fluent::MessagePackFactory.packer
+        when :unpacker
+          Fluent::MessagePackFactory.unpacker
+        else
+          raise ArgumentError, "unknown msgpack object type '#{type}'"
+        end
+      end
+
+      def capture_log(driver)
+        tmp = driver.instance.log.out
+        driver.instance.log.out = StringIO.new
+        yield
+        return driver.instance.log.out.string
+      ensure
+        driver.instance.log.out = tmp
+      end
+    end
+  end
+end

data/lib/fluent/test/input_test.rb

@@ -0,0 +1,172 @@
+#
+# Fluentd
+#
+#    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.
+#
+
+require 'fluent/engine'
+require 'fluent/time'
+require 'fluent/test/base'
+
+module Fluent
+  module Test
+    class InputTestDriver < TestDriver
+      def initialize(klass, &block)
+        super(klass, &block)
+        @emit_streams = []
+        @expects = nil
+        # for checking only the number of emitted records during run
+        @expected_emits_length = nil
+        @run_timeout = 5
+        @run_post_conditions = []
+      end
+
+      def expect_emit(tag, time, record)
+        (@expects ||= []) << [tag, time, record]
+        self
+      end
+
+      def expected_emits
+        @expects ||= []
+      end
+
+      attr_accessor :expected_emits_length
+      attr_accessor :run_timeout
+      attr_reader :emit_streams
+
+      def emits
+        all = []
+        @emit_streams.each {|tag,events|
+          events.each {|time,record|
+            all << [tag, time, record]
+          }
+        }
+        all
+      end
+
+      def events
+        all = []
+        @emit_streams.each {|tag,events|
+          all.concat events
+        }
+        all
+      end
+
+      def records
+        all = []
+        @emit_streams.each {|tag,events|
+          events.each {|time,record|
+            all << record
+          }
+        }
+        all
+      end
+
+      def register_run_post_condition(&block)
+        if block
+          @run_post_conditions << block
+        end
+      end
+
+      def register_run_breaking_condition(&block)
+        if block
+          @run_breaking_conditions ||= []
+          @run_breaking_conditions << block
+        end
+      end
+
+      def run_should_stop?
+        # Should stop running if post conditions are not registered.
+        return true unless @run_post_conditions
+
+        # Should stop running if all of the post conditions are true.
+        return true if @run_post_conditions.all? {|proc| proc.call }
+
+        # Should stop running if any of the breaking conditions is true.
+        # In this case, some post conditions may be not true.
+        return true if @run_breaking_conditions && @run_breaking_conditions.any? {|proc| proc.call }
+
+        false
+      end
+
+      module EmitStreamWrapper
+        def emit_stream_callee=(method)
+          @emit_stream_callee = method
+        end
+        def emit_stream(tag, es)
+          @emit_stream_callee.call(tag, es)
+        end
+      end
+
+      def run(num_waits = 10, &block)
+        m = method(:emit_stream)
+        unless Engine.singleton_class.ancestors.include?(EmitStreamWrapper)
+          Engine.singleton_class.prepend EmitStreamWrapper
+        end
+        Engine.emit_stream_callee = m
+        unless instance.router.singleton_class.ancestors.include?(EmitStreamWrapper)
+          instance.router.singleton_class.prepend EmitStreamWrapper
+        end
+        instance.router.emit_stream_callee = m
+
+        super(num_waits) {
+          block.call if block
+
+          if @expected_emits_length || @expects || @run_post_conditions
+            # counters for emits and emit_streams
+            i, j = 0, 0
+
+            # Events of expected length will be emitted at the end.
+            max_length = @expected_emits_length
+            max_length ||= @expects.length if @expects
+            if max_length
+              register_run_post_condition do
+                i == max_length
+              end
+            end
+
+            # Set runnning timeout to avoid infinite loop caused by some errors.
+            started_at = Time.now
+            register_run_breaking_condition do
+              Time.now >= started_at + @run_timeout
+            end
+
+            until run_should_stop?
+              if j >= @emit_streams.length
+                sleep 0.01
+                next
+              end
+
+              tag, events = @emit_streams[j]
+              events.each do |time, record|
+                if @expects
+                  assert_equal(@expects[i], [tag, time, record])
+                  assert_equal_event_time(@expects[i][1], time) if @expects[i][1].is_a?(Fluent::EventTime)
+                end
+                i += 1
+              end
+              j += 1
+            end
+            assert_equal(@expects.length, i) if @expects
+          end
+        }
+        self
+      end
+
+      private
+      def emit_stream(tag, es)
+        @emit_streams << [tag, es.to_a]
+      end
+    end
+  end
+end