fluentd-hubspot 0.14.14.1

data/test/plugin/test_filter_stdout.rb

@@ -0,0 +1,202 @@
+require_relative '../helper'
+require 'fluent/test/driver/filter'
+require 'fluent/plugin/filter_stdout'
+require 'timecop'
+require 'flexmock/test_unit'
+
+class StdoutFilterTest < Test::Unit::TestCase
+  include FlexMock::TestCase
+
+  def setup
+    Fluent::Test.setup
+    @old_tz = ENV["TZ"]
+    ENV["TZ"] = "UTC"
+    Timecop.freeze
+  end
+
+  def teardown
+    super # FlexMock::TestCase requires this
+    # http://flexmock.rubyforge.org/FlexMock/TestCase.html
+    Timecop.return
+    ENV["TZ"] = @old_tz
+  end
+
+  CONFIG = config_element('ROOT')
+
+  def create_driver(conf = CONFIG)
+    Fluent::Test::Driver::Filter.new(Fluent::Plugin::StdoutFilter).configure(conf)
+  end
+
+  def filter(d, time, record)
+    d.run {
+      d.feed("filter.test", time, record)
+    }
+    d.filtered_records
+  end
+
+  def test_through_record
+    d = create_driver
+    filtered = filter(d, event_time, {'test' => 'test'})
+    assert_equal([{'test' => 'test'}], filtered)
+  end
+
+  sub_test_case "flat style parameters" do
+    sub_test_case "configure" do
+      def test_configure_default
+        d = create_driver
+        d.run {}
+        assert_equal 'json', d.instance.formatter.output_type
+      end
+
+      data(json: "json",
+           hash: "hash",
+           ltsv: "ltsv")
+      def test_output_type(data)
+        d = create_driver(CONFIG + config_element("", "", { "output_type" => data }))
+        d.run {}
+        assert_equal data, d.instance.formatter.output_type
+      end
+
+      def test_invalid_output_type
+        assert_raise(Fluent::ConfigError) do
+          d = create_driver(CONFIG + config_element("", "", { "output_type" => "foo" }))
+          d.run {}
+        end
+      end
+    end
+
+    def test_output_type_json
+      d = create_driver(CONFIG + config_element("", "", { "output_type" => "json" }))
+      etime = event_time("2016-10-07 21:09:31.012345678 UTC")
+      out = capture_log(d) { filter(d, etime, {'test' => 'test'}) }
+      assert_equal "2016-10-07 21:09:31.012345678 +0000 filter.test: {\"test\":\"test\"}\n", out
+
+      # NOTE: Float::NAN is not jsonable
+      d = create_driver(CONFIG + config_element("", "", { "output_type" => "json" }))
+      flexmock(d.instance.router).should_receive(:emit_error_event)
+      filter(d, etime, {'test' => Float::NAN})
+    end
+
+    def test_output_type_hash
+      d = create_driver(CONFIG + config_element("", "", { "output_type" => "hash" }))
+      etime = event_time("2016-10-07 21:09:31.012345678 UTC")
+      out = capture_log(d) { filter(d, etime, {'test' => 'test'}) }
+      assert_equal "2016-10-07 21:09:31.012345678 +0000 filter.test: {\"test\"=>\"test\"}\n", out
+
+      # NOTE: Float::NAN is not jsonable, but hash string can output it.
+      d = create_driver(CONFIG + config_element("", "", { "output_type" => "hash" }))
+      out = capture_log(d) { filter(d, etime, {'test' => Float::NAN}) }
+      assert_equal "2016-10-07 21:09:31.012345678 +0000 filter.test: {\"test\"=>NaN}\n", out
+    end
+
+    # Use include_time_key to output the message's time
+    def test_include_time_key
+      config = config_element("", "", {
+                                "output_type" => "json",
+                                "include_time_key" => true,
+                                "localtime" => false
+                              })
+      d = create_driver(config)
+      etime = event_time("2016-10-07 21:09:31.012345678 UTC")
+      out = capture_log(d) { filter(d, etime, {'test' => 'test'}) }
+      assert_equal "2016-10-07 21:09:31.012345678 +0000 filter.test: {\"test\":\"test\",\"time\":\"2016-10-07T21:09:31Z\"}\n", out
+    end
+
+    # out_stdout formatter itself can also be replaced
+    def test_format_json
+      d = create_driver(CONFIG + config_element("", "", { "format" => "json" }))
+      out = capture_log(d) { filter(d, event_time, {'test' => 'test'}) }
+      assert_equal "{\"test\":\"test\"}\n", out
+    end
+  end
+
+  sub_test_case "with <format> sub section" do
+    sub_test_case "configure" do
+      def test_default
+        conf = config_element
+        conf.elements << config_element("format", "", { "@type" => "stdout"})
+        d = create_driver(conf)
+        d.run {}
+        assert_equal("json", d.instance.formatter.output_type)
+      end
+
+      data(json: "json",
+           hash: "hash",
+           ltsv: "ltsv")
+      def test_output_type(data)
+        conf = config_element
+        conf.elements << config_element("format", "", { "@type" => "stdout", "output_type" => data })
+        d = create_driver(conf)
+        d.run {}
+        assert_equal(data, d.instance.formatter.output_type)
+      end
+
+      def test_invalid_output_type
+        conf = config_element
+        conf.elements << config_element("format", "", { "@type" => "stdout", "output_type" => "foo" })
+        assert_raise(Fluent::ConfigError) do
+          d = create_driver(conf)
+          d.run {}
+        end
+      end
+    end
+
+    sub_test_case "output_type" do
+      def test_json
+        conf = config_element
+        conf.elements << config_element("format", "", { "@type" => "stdout", "output_type" => "json" })
+        d = create_driver(conf)
+        etime = event_time("2016-10-07 21:09:31.012345678 UTC")
+        out = capture_log(d) { filter(d, etime, {'test' => 'test'}) }
+        assert_equal "2016-10-07 21:09:31.012345678 +0000 filter.test: {\"test\":\"test\"}\n", out
+      end
+
+      def test_json_nan
+        # NOTE: Float::NAN is not jsonable
+        conf = config_element
+        conf.elements << config_element("format", "", { "@type" => "stdout", "output_type" => "json" })
+        d = create_driver(conf)
+        etime = event_time("2016-10-07 21:09:31.012345678 UTC")
+        flexmock(d.instance.router).should_receive(:emit_error_event)
+        filter(d, etime, {'test' => Float::NAN})
+      end
+
+      def test_hash
+        conf = config_element
+        conf.elements << config_element("format", "", { "@type" => "stdout", "output_type" => "hash" })
+        d = create_driver(conf)
+        etime = event_time("2016-10-07 21:09:31.012345678 UTC")
+        out = capture_log(d) { filter(d, etime, {'test' => 'test'}) }
+        assert_equal "2016-10-07 21:09:31.012345678 +0000 filter.test: {\"test\"=>\"test\"}\n", out
+      end
+
+      def test_hash_nan
+        # NOTE: Float::NAN is not jsonable, but hash string can output it.
+        conf = config_element
+        conf.elements << config_element("format", "", { "@type" => "stdout", "output_type" => "hash" })
+        d = create_driver(conf)
+        etime = event_time("2016-10-07 21:09:31.012345678 UTC")
+        out = capture_log(d) { filter(d, etime, {'test' => Float::NAN}) }
+        assert_equal "2016-10-07 21:09:31.012345678 +0000 filter.test: {\"test\"=>NaN}\n", out
+      end
+
+      # Use include_time_key to output the message's time
+      def test_include_time_key
+        conf = config_element
+        conf.elements << config_element("format", "", {
+                                          "@type" => "stdout",
+                                          "output_type" => "json"
+                                        })
+        conf.elements << config_element("inject", "", {
+                                          "time_key" => "time",
+                                          "time_type" => "string",
+                                          "localtime" => false
+                                          })
+        d = create_driver(conf)
+        etime = event_time("2016-10-07 21:09:31.012345678 UTC")
+        out = capture_log(d) { filter(d, etime, {'test' => 'test'}) }
+        assert_equal "2016-10-07 21:09:31.012345678 +0000 filter.test: {\"test\":\"test\",\"time\":\"2016-10-07T21:09:31Z\"}\n", out
+      end
+    end
+  end
+end

data/test/plugin/test_formatter_csv.rb

@@ -0,0 +1,111 @@
+require_relative '../helper'
+require 'fluent/test/driver/formatter'
+require 'fluent/plugin/formatter_csv'
+
+class CsvFormatterTest < ::Test::Unit::TestCase
+
+  def setup
+    @time = event_time
+  end
+
+  CONF = %[
+    fields a,b,c
+  ]
+
+  def create_driver(conf = CONF)
+    Fluent::Test::Driver::Formatter.new(Fluent::Plugin::CsvFormatter).configure(conf)
+  end
+
+  def tag
+    "tag"
+  end
+
+  def test_config_params
+    d = create_driver
+    assert_equal(',', d.instance.delimiter)
+    assert_equal(true, d.instance.force_quotes)
+    assert_equal(['a', 'b', 'c'], d.instance.fields)
+  end
+
+  data('empty array' => [],
+       'array including empty string' => ['', ''])
+  def test_empty_fields(param)
+    assert_raise Fluent::ConfigError do
+      create_driver('fields' => param)
+    end
+  end
+
+  data(
+    'tab_char' => ["\t", '\t'],
+    'tab_string' => ["\t", 'TAB'],
+    'pipe' => ['|', '|'])
+  def test_config_params_with_customized_delimiters(data)
+    expected, target = data
+    d = create_driver("delimiter" => target, 'fields' => 'a,b,c')
+    assert_equal expected, d.instance.delimiter
+  end
+
+  def test_format
+    d = create_driver("fields" => "message,message2")
+    formatted = d.instance.format(tag, @time, {
+                                    'message' => 'awesome',
+                                    'message2' => 'awesome2'
+                                  })
+    assert_equal("\"awesome\",\"awesome2\"\n", formatted)
+  end
+
+  def test_format_without_newline
+    d = create_driver("fields" => "message,message2", "add_newline" => false)
+    formatted = d.instance.format(tag, @time, {
+                                    'message' => 'awesome',
+                                    'message2' => 'awesome2'
+                                  })
+    assert_equal("\"awesome\",\"awesome2\"", formatted)
+  end
+
+  def test_format_with_customized_delimiters
+    d = create_driver("fields" => "message,message2",
+                      "delimiter" => "\t")
+    formatted = d.instance.format(tag, @time, {
+                                    'message' => 'awesome',
+                                    'message2' => 'awesome2'
+                                  })
+    assert_equal("\"awesome\"\t\"awesome2\"\n", formatted)
+  end
+
+  def test_format_with_non_quote
+    d = create_driver("fields" => "message,message2",
+                      "force_quotes" => false)
+    formatted = d.instance.format(tag, @time, {
+                                    'message' => 'awesome',
+                                    'message2' => 'awesome2'
+                                  })
+    assert_equal("awesome,awesome2\n", formatted)
+  end
+
+  data(
+    'nil' => {
+      'message' => 'awesome',
+      'message2' => nil,
+      'message3' => 'awesome3'
+    },
+    'blank' => {
+      'message' => 'awesome',
+      'message2' => '',
+      'message3' => 'awesome3'
+    })
+  def test_format_with_empty_fields(data)
+    d = create_driver("fields" => "message,message2,message3")
+    formatted = d.instance.format(tag, @time, data)
+    assert_equal("\"awesome\",\"\",\"awesome3\"\n", formatted)
+  end
+
+  data(
+    'normally' => 'one,two,three',
+    'white_space' => 'one , two , three',
+    'blank' => 'one,,two,three')
+  def test_config_params_with_fields(data)
+    d = create_driver('fields' => data)
+    assert_equal %w(one two three), d.instance.fields
+  end
+end

data/test/plugin/test_formatter_hash.rb

@@ -0,0 +1,35 @@
+require_relative '../helper'
+require 'fluent/test/driver/formatter'
+require 'fluent/plugin/formatter_hash'
+
+class HashFormatterTest < ::Test::Unit::TestCase
+  def setup
+    @time = event_time
+  end
+
+  def create_driver(conf = "")
+    Fluent::Test::Driver::Formatter.new(Fluent::Plugin::HashFormatter).configure(conf)
+  end
+
+  def tag
+    "tag"
+  end
+
+  def record
+    {'message' => 'awesome', 'greeting' => 'hello'}
+  end
+
+  def test_format
+    d = create_driver({})
+    formatted = d.instance.format(tag, @time, record)
+
+    assert_equal(%Q!{"message"=>"awesome", "greeting"=>"hello"}\n!, formatted.encode(Encoding::UTF_8))
+  end
+
+  def test_format_without_newline
+    d = create_driver('add_newline' => false)
+    formatted = d.instance.format(tag, @time, record)
+
+    assert_equal(%Q!{"message"=>"awesome", "greeting"=>"hello"}!, formatted.encode(Encoding::UTF_8))
+  end
+end

data/test/plugin/test_formatter_json.rb

@@ -0,0 +1,51 @@
+require_relative '../helper'
+require 'json'
+require 'fluent/test/driver/formatter'
+require 'fluent/plugin/formatter_json'
+
+class JsonFormatterTest < ::Test::Unit::TestCase
+
+  def setup
+    @time = event_time
+  end
+
+  def create_driver(conf = "")
+    Fluent::Test::Driver::Formatter.new(Fluent::Plugin::JSONFormatter).configure(conf)
+  end
+
+  def tag
+    "tag"
+  end
+
+  def record
+    {'message' => 'awesome'}
+  end
+
+  def symbolic_record
+    {:message => :awesome}
+  end
+
+  data('oj' => 'oj', 'yajl' => 'yajl')
+  def test_format(data)
+    d = create_driver('json_parser' => data)
+    formatted = d.instance.format(tag, @time, record)
+
+    assert_equal("#{JSON.generate(record)}\n", formatted)
+  end
+
+  data('oj' => 'oj', 'yajl' => 'yajl')
+  def test_format_without_nl(data)
+    d = create_driver('json_parser' => data, 'add_newline' => false)
+    formatted = d.instance.format(tag, @time, record)
+
+    assert_equal(JSON.generate(record), formatted)
+  end
+
+  data('oj' => 'oj', 'yajl' => 'yajl')
+  def test_format_with_symbolic_record(data)
+    d = create_driver('json_parser' => data)
+    formatted = d.instance.format(tag, @time, symbolic_record)
+
+    assert_equal("#{JSON.generate(record)}\n", formatted)
+  end
+end

data/test/plugin/test_formatter_ltsv.rb

@@ -0,0 +1,59 @@
+require_relative '../helper'
+require 'fluent/test/driver/formatter'
+require 'fluent/plugin/formatter_ltsv'
+
+class LabeledTSVFormatterTest < ::Test::Unit::TestCase
+  def setup
+    @time = event_time
+  end
+
+  def create_driver(conf = "")
+    Fluent::Test::Driver::Formatter.new(Fluent::Plugin::LabeledTSVFormatter).configure(conf)
+  end
+
+  def tag
+    "tag"
+  end
+
+  def record
+    {'message' => 'awesome', 'greeting' => 'hello'}
+  end
+
+  def test_config_params
+    d = create_driver
+    assert_equal "\t", d.instance.delimiter
+    assert_equal  ":", d.instance.label_delimiter
+
+    d = create_driver(
+      'delimiter'       => ',',
+      'label_delimiter' => '=',
+    )
+
+    assert_equal ",", d.instance.delimiter
+    assert_equal "=", d.instance.label_delimiter
+  end
+
+  def test_format
+    d = create_driver({})
+    formatted = d.instance.format(tag, @time, record)
+
+    assert_equal("message:awesome\tgreeting:hello\n", formatted)
+  end
+
+  def test_format_without_newline
+    d = create_driver('add_newline' => false)
+    formatted = d.instance.format(tag, @time, record)
+
+    assert_equal("message:awesome\tgreeting:hello", formatted)
+  end
+
+  def test_format_with_customized_delimiters
+    d = create_driver(
+      'delimiter'       => ',',
+      'label_delimiter' => '=',
+    )
+    formatted = d.instance.format(tag, @time, record)
+
+    assert_equal("message=awesome,greeting=hello\n", formatted)
+  end
+end