fluentd-hubspot 0.14.14.1

data/test/config/test_dsl.rb

@@ -0,0 +1,415 @@
+require_relative '../helper'
+require 'fluent/config/element'
+require "fluent/config/dsl"
+
+TMP_DIR = File.dirname(__FILE__) + "/tmp/config_dsl#{ENV['TEST_ENV_NUMBER']}"
+def write_config(path, data)
+  FileUtils.mkdir_p(File.dirname(path))
+  File.open(path, "w") {|f| f.write data }
+end
+
+def prepare_config1
+  write_config "#{TMP_DIR}/config_test_1.conf", %[
+  k1 root_config
+  include dir/config_test_2.conf  #
+  @include #{TMP_DIR}/config_test_4.conf
+  include file://#{TMP_DIR}/config_test_5.conf
+  @include config.d/*.conf
+]
+  write_config "#{TMP_DIR}/dir/config_test_2.conf", %[
+  k2 relative_path_include
+  @include ../config_test_3.conf
+]
+  write_config "#{TMP_DIR}/config_test_3.conf", %[
+  k3 relative_include_in_included_file
+]
+  write_config "#{TMP_DIR}/config_test_4.conf", %[
+  k4 absolute_path_include
+]
+  write_config "#{TMP_DIR}/config_test_5.conf", %[
+  k5 uri_include
+]
+  write_config "#{TMP_DIR}/config.d/config_test_6.conf", %[
+  k6 wildcard_include_1
+  <elem1 name>
+    include normal_parameter
+  </elem1>
+]
+  write_config "#{TMP_DIR}/config.d/config_test_7.conf", %[
+  k7 wildcard_include_2
+]
+  write_config "#{TMP_DIR}/config.d/config_test_8.conf", %[
+  <elem2 name>
+    @include ../dir/config_test_9.conf
+  </elem2>
+]
+  write_config "#{TMP_DIR}/dir/config_test_9.conf", %[
+  k9 embeded
+  <elem3 name>
+    nested nested_value
+    include hoge
+  </elem3>
+]
+  write_config "#{TMP_DIR}/config.d/00_config_test_8.conf", %[
+  k8 wildcard_include_3
+  <elem4 name>
+    include normal_parameter
+  </elem4>
+]
+end
+
+def prepare_config2
+  write_config "#{TMP_DIR}/config_test_1.rb", DSL_CONFIG_EXAMPLE
+end
+
+DSL_CONFIG_EXAMPLE = %q[
+worker {
+  hostname = "myhostname"
+
+  (0..9).each { |i|
+    source {
+      type :tail
+      path "/var/log/httpd/access.part#{i}.log"
+
+      filter ('bar.**') {
+        type :hoge
+        val1 "moge"
+        val2 ["foo", "bar", "baz"]
+        val3 10
+        id :hoge
+
+        subsection {
+          foo "bar"
+        }
+        subsection {
+          foo "baz"
+        }
+      }
+
+      filter ('foo.**') {
+        type "pass"
+      }
+
+      match ('{foo,bar}.**') {
+        type "file"
+        path "/var/log/httpd/access.#{hostname}.#{i}.log"
+      }
+    }
+  }
+}
+]
+
+DSL_CONFIG_EXAMPLE_WITHOUT_WORKER = %q[
+hostname = "myhostname"
+
+source {
+  type :tail
+  path "/var/log/httpd/access.part.log"
+
+  element {
+    name "foo"
+  }
+
+  match ('{foo,bar}.**') {
+    type "file"
+    path "/var/log/httpd/access.full.log"
+  }
+}
+]
+
+DSL_CONFIG_EXAMPLE_FOR_INCLUDE_CONF = %q[
+include "#{TMP_DIR}/config_test_1.conf"
+]
+
+DSL_CONFIG_EXAMPLE_FOR_INCLUDE_RB = %q[
+include "#{TMP_DIR}/config_test_1.rb"
+]
+
+DSL_CONFIG_RETURNS_NON_ELEMENT = %q[
+worker {
+}
+[]
+]
+
+DSL_CONFIG_WRONG_SYNTAX1 = %q[
+match
+]
+DSL_CONFIG_WRONG_SYNTAX2 = %q[
+match('aa','bb'){
+  type :null
+}
+]
+DSL_CONFIG_WRONG_SYNTAX3 = %q[
+match('aa','bb')
+]
+DSL_CONFIG_WRONG_SYNTAX4 = %q[
+include
+]
+
+module Fluent::Config
+  class TestDSLParser < ::Test::Unit::TestCase
+    sub_test_case 'with worker tag on top level' do
+      def setup
+        @root = Fluent::Config::DSL::Parser.parse(DSL_CONFIG_EXAMPLE, 'dsl_config.rb')
+      end
+
+      sub_test_case '.parse' do
+        test 'makes root element' do
+          assert_equal('ROOT', @root.name)
+          assert_predicate(@root.arg, :empty?)
+          assert_equal(0, @root.keys.size)
+        end
+
+        test 'makes worker element for worker tag' do
+          assert_equal(1, @root.elements.size)
+
+          worker = @root.elements.first
+          assert_equal('worker', worker.name)
+          assert_predicate(worker.arg, :empty?)
+          assert_equal(0, worker.keys.size)
+          assert_equal(10, worker.elements.size)
+        end
+
+        test 'makes subsections for blocks, with variable substitution' do
+          ele4 = @root.elements.first.elements[4]
+
+          assert_equal('source', ele4.name)
+          assert_predicate(ele4.arg, :empty?)
+          assert_equal(2, ele4.keys.size)
+          assert_equal('tail', ele4['type'])
+          assert_equal("/var/log/httpd/access.part4.log", ele4['path'])
+        end
+
+        test 'makes user-defined sections with blocks' do
+          filter0 = @root.elements.first.elements[4].elements.first
+
+          assert_equal('filter', filter0.name)
+          assert_equal('bar.**', filter0.arg)
+          assert_equal('hoge', filter0['type'])
+          assert_equal('moge', filter0['val1'])
+          assert_equal(JSON.dump(['foo', 'bar', 'baz']), filter0['val2'])
+          assert_equal('10', filter0['val3'])
+          assert_equal('hoge', filter0['id'])
+
+          assert_equal(2, filter0.elements.size)
+          assert_equal('subsection', filter0.elements[0].name)
+          assert_equal('bar', filter0.elements[0]['foo'])
+          assert_equal('subsection', filter0.elements[1].name)
+          assert_equal('baz', filter0.elements[1]['foo'])
+        end
+
+        test 'makes values with user-assigned variable substitutions' do
+          match0 = @root.elements.first.elements[4].elements.last
+
+          assert_equal('match', match0.name)
+          assert_equal('{foo,bar}.**', match0.arg)
+          assert_equal('file', match0['type'])
+          assert_equal('/var/log/httpd/access.myhostname.4.log', match0['path'])
+        end
+      end
+    end
+
+    sub_test_case 'without worker tag on top level' do
+      def setup
+        @root = Fluent::Config::DSL::Parser.parse(DSL_CONFIG_EXAMPLE_WITHOUT_WORKER, 'dsl_config_without_worker.rb')
+      end
+
+      sub_test_case '.parse' do
+        test 'makes root element' do
+          assert_equal('ROOT', @root.name)
+          assert_predicate(@root.arg, :empty?)
+          assert_equal(0, @root.keys.size)
+        end
+
+        test 'does not make worker element implicitly because DSL configuration does not support v10 compat mode' do
+          assert_equal(1, @root.elements.size)
+          assert_equal('source', @root.elements.first.name)
+          refute(@root.elements.find { |e| e.name == 'worker' })
+        end
+      end
+    end
+
+    sub_test_case 'with include conf' do
+      def setup
+        prepare_config1
+        @root = Fluent::Config::DSL::Parser.parse(DSL_CONFIG_EXAMPLE_FOR_INCLUDE_CONF, 'dsl_config_for_include.conf')
+      end
+      test 'include config' do
+        assert_equal('root_config', @root['k1'])
+        assert_equal('relative_path_include', @root['k2'])
+        assert_equal('relative_include_in_included_file', @root['k3'])
+        assert_equal('absolute_path_include', @root['k4'])
+        assert_equal('uri_include', @root['k5'])
+        assert_equal('wildcard_include_1', @root['k6'])
+        assert_equal('wildcard_include_2', @root['k7'])
+        assert_equal('wildcard_include_3', @root['k8'])
+        assert_equal([
+            'k1',
+            'k2',
+            'k3',
+            'k4',
+            'k5',
+            'k8', # Because of the file name this comes first.
+            'k6',
+            'k7',
+          ], @root.keys)
+
+        elem1 = @root.elements.find { |e| e.name == 'elem1' }
+        assert(elem1)
+        assert_equal('name', elem1.arg)
+        assert_equal('normal_parameter', elem1['include'])
+
+        elem2 = @root.elements.find { |e| e.name == 'elem2' }
+        assert(elem2)
+        assert_equal('name', elem2.arg)
+        assert_equal('embeded', elem2['k9'])
+        assert_not_include(elem2, 'include')
+
+        elem3 = elem2.elements.find { |e| e.name == 'elem3' }
+        assert(elem3)
+        assert_equal('nested_value', elem3['nested'])
+        assert_equal('hoge', elem3['include'])
+      end
+
+      # TODO: Add uri based include spec
+    end
+
+    sub_test_case 'with include rb' do
+      def setup
+        prepare_config2
+        @root = Fluent::Config::DSL::Parser.parse(DSL_CONFIG_EXAMPLE_FOR_INCLUDE_RB, 'dsl_config_for_include.rb')
+      end
+      sub_test_case '.parse' do
+        test 'makes root element' do
+          assert_equal('ROOT', @root.name)
+          assert_predicate(@root.arg, :empty?)
+          assert_equal(0, @root.keys.size)
+        end
+
+        test 'makes worker element for worker tag' do
+          assert_equal(1, @root.elements.size)
+
+          worker = @root.elements.first
+          assert_equal('worker', worker.name)
+          assert_predicate(worker.arg, :empty?)
+          assert_equal(0, worker.keys.size)
+          assert_equal(10, worker.elements.size)
+        end
+
+        test 'makes subsections for blocks, with variable substitution' do
+          ele4 = @root.elements.first.elements[4]
+
+          assert_equal('source', ele4.name)
+          assert_predicate(ele4.arg, :empty?)
+          assert_equal(2, ele4.keys.size)
+          assert_equal('tail', ele4['type'])
+          assert_equal("/var/log/httpd/access.part4.log", ele4['path'])
+        end
+
+        test 'makes user-defined sections with blocks' do
+          filter0 = @root.elements.first.elements[4].elements.first
+
+          assert_equal('filter', filter0.name)
+          assert_equal('bar.**', filter0.arg)
+          assert_equal('hoge', filter0['type'])
+          assert_equal('moge', filter0['val1'])
+          assert_equal(JSON.dump(['foo', 'bar', 'baz']), filter0['val2'])
+          assert_equal('10', filter0['val3'])
+          assert_equal('hoge', filter0['id'])
+
+          assert_equal(2, filter0.elements.size)
+          assert_equal('subsection', filter0.elements[0].name)
+          assert_equal('bar', filter0.elements[0]['foo'])
+          assert_equal('subsection', filter0.elements[1].name)
+          assert_equal('baz', filter0.elements[1]['foo'])
+        end
+
+        test 'makes values with user-assigned variable substitutions' do
+          match0 = @root.elements.first.elements[4].elements.last
+
+          assert_equal('match', match0.name)
+          assert_equal('{foo,bar}.**', match0.arg)
+          assert_equal('file', match0['type'])
+          assert_equal('/var/log/httpd/access.myhostname.4.log', match0['path'])
+        end
+      end
+    end
+
+    sub_test_case 'with configuration that returns non element on top' do
+      sub_test_case '.parse' do
+        test 'does not crash' do
+          Fluent::Config::DSL::Parser.parse(DSL_CONFIG_RETURNS_NON_ELEMENT, 'dsl_config_returns_non_element.rb')
+        end
+      end
+    end
+
+    sub_test_case 'with configuration with wrong arguments for specific elements' do
+      sub_test_case '.parse' do
+        test 'raises ArgumentError correctly' do
+          assert_raise(ArgumentError) { Fluent::Config::DSL::Parser.parse(DSL_CONFIG_WRONG_SYNTAX1, 'dsl_config_wrong_syntax1') }
+          assert_raise(ArgumentError) { Fluent::Config::DSL::Parser.parse(DSL_CONFIG_WRONG_SYNTAX2, 'dsl_config_wrong_syntax2') }
+          assert_raise(ArgumentError) { Fluent::Config::DSL::Parser.parse(DSL_CONFIG_WRONG_SYNTAX3, 'dsl_config_wrong_syntax3') }
+          assert_raise(ArgumentError) { Fluent::Config::DSL::Parser.parse(DSL_CONFIG_WRONG_SYNTAX4, 'dsl_config_wrong_syntax4') }
+        end
+      end
+    end
+
+    sub_test_case 'with ruby keyword, that provides ruby Kernel module features' do
+      sub_test_case '.parse' do
+        test 'can get result of Kernel.open() by ruby.open()' do
+          uname_string = `uname -a`
+          root = Fluent::Config::DSL::Parser.parse(<<DSL)
+worker {
+  uname_str = ruby.open('|uname -a'){|out| out.read}
+  source {
+    uname uname_str
+  }
+}
+DSL
+          worker = root.elements.first
+          assert_equal('worker', worker.name)
+          source = worker.elements.first
+          assert_equal('source', source.name)
+          assert_equal(1, source.keys.size)
+          assert_equal(uname_string, source['uname'])
+        end
+
+        test 'accepts ruby keyword with block, which allow to use methods included from ::Kernel' do
+          root = Fluent::Config::DSL::Parser.parse(<<DSL)
+worker {
+  ruby_version = ruby {
+    require 'erb'
+    ERB.new('<%= RUBY_VERSION %> from erb').result
+  }
+  source {
+    version ruby_version
+  }
+}
+DSL
+          worker = root.elements.first
+          assert_equal('worker', worker.name)
+          source = worker.elements.first
+          assert_equal('source', source.name)
+          assert_equal(1, source.keys.size)
+          assert_equal("#{RUBY_VERSION} from erb", source['version'])
+        end
+
+        test 'raises NoMethodError when configuration DSL elements are written in ruby block' do
+          conf = <<DSL
+worker {
+  ruby {
+    source {
+      type "tail"
+    }
+  }
+  source {
+    uname uname_str
+  }
+}
+DSL
+          assert_raise(NoMethodError) { Fluent::Config::DSL::Parser.parse(conf) }
+        end
+      end
+    end
+  end
+end

data/test/config/test_element.rb

@@ -0,0 +1,403 @@
+require_relative '../helper'
+require 'fluent/config/element'
+require 'fluent/config/configure_proxy'
+require 'fluent/configurable'
+
+class TestConfigElement < ::Test::Unit::TestCase
+  def element(name = 'ROOT', arg = '', attrs = {}, elements = [], unused = nil)
+    Fluent::Config::Element.new(name, arg, attrs, elements, unused)
+  end
+
+  sub_test_case '#elements=' do
+    test 'elements can be set by others' do
+      e = element()
+      assert_equal [], e.elements
+
+      e1 = element('e1')
+      e2 = element('e2')
+      e.elements = [e1, e2]
+      assert_equal [e1, e2], e.elements
+    end
+  end
+
+  sub_test_case '#elements' do
+    setup do
+      @c1 = element('source')
+      @c2 = element('source', 'yay')
+      @c3 = element('match', 'test.**')
+      @c4 = element('label', '@mytest', {}, [ element('filter', '**'), element('match', '**') ])
+      children = [@c1, @c2, @c3, @c4]
+      @e = Fluent::Config::Element.new('ROOT', '', {}, children)
+    end
+
+    test 'returns all elements without arguments' do
+      assert_equal [@c1, @c2, @c3, @c4], @e.elements
+    end
+
+    test 'returns elements with specified names' do
+      assert_equal [@c1, @c2, @c3], @e.elements('source', 'match')
+      assert_equal [@c3, @c4], @e.elements('match', 'label')
+    end
+
+    test 'returns elements with specified name, and arg if specified' do
+      assert_equal [@c1, @c2], @e.elements(name: 'source')
+      assert_equal [@c2], @e.elements(name: 'source', arg: 'yay')
+    end
+
+    test 'keyword argument name/arg and names are exclusive' do
+      assert_raise ArgumentError do
+        @e.elements('source', name: 'match')
+      end
+      assert_raise ArgumentError do
+        @e.elements('source', 'match', name: 'label', arg: '@mytest')
+      end
+    end
+
+    test 'specifying only arg without name is invalid' do
+      assert_raise ArgumentError do
+        @e.elements(arg: '@mytest')
+      end
+    end
+  end
+
+  sub_test_case '#initialize' do
+    test 'creates object with blank attrs and elements' do
+      e = element('ROOT', '', {}, [])
+      assert_equal([], e.elements)
+    end
+
+    test 'creates object which contains attrs and elements' do
+      e = element('ROOT', '', {"k1" => "v1", "k2" => "v2"}, [
+                    element('test', 'mydata', {'k3' => 'v3'}, [])
+                  ])
+      assert_equal('ROOT', e.name)
+      assert_equal('',  e.arg)
+      assert_equal('v1', e["k1"])
+      assert_equal('v2', e["k2"])
+      assert_equal(1, e.elements.size)
+      e.each_element('test') do |el|
+        assert_equal('test', el.name)
+        assert_equal('mydata', el.arg)
+        assert_equal('v3', el["k3"])
+      end
+    end
+
+    test 'creates object which contains attrs, elements and unused' do
+      e = element('ROOT', '', {"k1" => "v1", "k2" => "v2", "k4" => "v4"}, [
+                    element('test', 'mydata', {'k3' => 'v3'}, [])
+                  ], "k3")
+      assert_equal("k3", e.unused)
+      assert_equal('ROOT', e.name)
+      assert_equal('',  e.arg)
+      assert_equal('v1', e["k1"])
+      assert_equal('v2', e["k2"])
+      assert_equal('v4', e["k4"])
+      assert_equal(1, e.elements.size)
+      e.each_element('test') do |el|
+        assert_equal('test', el.name)
+        assert_equal('mydata', el.arg)
+        assert_equal('v3', el["k3"])
+      end
+      assert_equal("k3", e.unused)
+    end
+  end
+
+  sub_test_case "@unused" do
+    sub_test_case '#[] has side effect for @unused' do
+      test 'without unused argument' do
+        e = element('ROOT', '', {"k1" => "v1", "k2" => "v2", "k4" => "v4"}, [
+                      element('test', 'mydata', {'k3' => 'v3'}, [])
+                    ])
+        assert_equal(["k1", "k2", "k4"], e.unused)
+        assert_equal('v1', e["k1"])
+        assert_equal(["k2", "k4"], e.unused)
+        assert_equal('v2', e["k2"])
+        assert_equal(["k4"], e.unused)
+        assert_equal('v4', e["k4"])
+        assert_equal([], e.unused)
+      end
+
+      test 'with unused argument' do
+        e = element('ROOT', '', {"k1" => "v1", "k2" => "v2", "k4" => "v4"}, [
+                      element('test', 'mydata', {'k3' => 'v3'}, [])
+                    ], ["k4"])
+        assert_equal(["k4"], e.unused)
+        assert_equal('v1', e["k1"])
+        assert_equal(["k4"], e.unused)
+        assert_equal('v2', e["k2"])
+        assert_equal(["k4"], e.unused)
+        assert_equal('v4', e["k4"])
+        # only consume for "k4"
+        assert_equal([], e.unused)
+      end
+    end
+  end
+
+  sub_test_case '#add_element' do
+    test 'elements can be set by #add_element' do
+      e = element()
+      assert_equal [], e.elements
+
+      e.add_element('e1', '')
+      e.add_element('e2', '')
+      assert_equal [element('e1', ''), element('e2', '')], e.elements
+    end
+  end
+
+  sub_test_case '#==' do
+    sub_test_case 'compare with two element objects' do
+      test 'equal' do
+        e1 = element('ROOT', '', {}, [])
+        e2 = element('ROOT', '', {}, [])
+        assert_true(e1 == e2)
+      end
+
+      data("differ args" => [Fluent::Config::Element.new('ROOT', '', {}, []),
+                             Fluent::Config::Element.new('ROOT', 'mydata', {}, [])],
+           "differ keys" => [Fluent::Config::Element.new('ROOT', 'mydata', {}, []),
+                             Fluent::Config::Element.new('ROOT', 'mydata', {"k1" => "v1"}, [])],
+           "differ elemnts" =>
+           [Fluent::Config::Element.new('ROOT', 'mydata', {"k1" => "v1"}, []),
+            Fluent::Config::Element.new('ROOT', 'mydata', {"k1" => "v1"}, [
+              Fluent::Config::Element.new('test', 'mydata', {'k3' => 'v3'}, [])
+            ])])
+      test 'not equal' do |data|
+        e1, e2 = data
+        assert_false(e1 == e2)
+      end
+    end
+  end
+
+  sub_test_case '#+' do
+    test 'can merge 2 elements: object side is primary' do
+      e1 = element('ROOT', 'mydata', {"k1" => "v1"}, [])
+      e2 = element('ROOT', 'mydata2', {"k1" => "ignored", "k2" => "v2"}, [
+                     element('test', 'ext', {'k3' => 'v3'}, [])
+                   ])
+      e = e1 + e2
+
+      assert_equal('ROOT', e.name)
+      assert_equal('mydata', e.arg)
+      assert_equal('v1', e['k1'])
+      assert_equal('v2', e['k2'])
+      assert_equal(1, e.elements.size)
+      e.each_element('test') do |el|
+        assert_equal('test', el.name)
+        assert_equal('ext', el.arg)
+        assert_equal('v3', el["k3"])
+      end
+    end
+  end
+
+  sub_test_case '#check_not_fetched' do
+    sub_test_case 'without unused' do
+      test 'can get attribute keys and original Config::Element' do
+        e = element('ROOT', 'mydata', {"k1" => "v1"}, [])
+        e.check_not_fetched { |key, elem|
+          assert_equal("k1", key)
+          assert_equal(e, elem)
+        }
+      end
+    end
+
+    sub_test_case 'with unused' do
+      test 'can get unused marked attribute keys and original Config::Element' do
+        e = element('ROOT', 'mydata', {"k1" => "v1", "k2" => "unused", "k3" => "k3"})
+        e.unused = "k2"
+        e.check_not_fetched { |key, elem|
+          assert_equal("k2", key)
+          assert_equal(e, elem)
+        }
+      end
+    end
+  end
+
+  sub_test_case '#has_key?' do
+    test 'can get boolean with key name' do
+      e = element('ROOT', 'mydata', {"k1" => "v1"}, [])
+      assert_true(e.has_key?("k1"))
+      assert_false(e.has_key?("noexistent"))
+    end
+  end
+
+
+  sub_test_case '#to_s' do
+    data("without v1_config" => [false, <<-CONF
+<ROOT>
+  k1 v1
+  k2 "stringVal"
+  <test ext>
+    k2 v2
+  </test>
+</ROOT>
+CONF
+                                ],
+         "with v1_config" => [true, <<-CONF
+<ROOT>
+  k1 v1
+  k2 "stringVal"
+  <test ext>
+    k2 v2
+  </test>
+</ROOT>
+CONF
+                             ],
+        )
+    test 'dump config element with #to_s' do |data|
+      v1_config, expected = data
+      e = element('ROOT', '', {'k1' => 'v1', "k2" =>"\"stringVal\""}, [
+                    element('test', 'ext', {'k2' => 'v2'}, [])
+                  ])
+      e.v1_config = v1_config
+      dump = expected
+      assert_not_equal(e.inspect, e.to_s)
+      assert_equal(dump, e.to_s)
+    end
+  end
+
+  sub_test_case '#inspect' do
+    test 'dump config element with #inspect' do
+      e = element('ROOT', '', {'k1' => 'v1'}, [
+                   element('test', 'ext', {'k2' => 'v2'}, [])
+                  ])
+      dump = <<-CONF
+name:ROOT, arg:, {\"k1\"=>\"v1\"}, [name:test, arg:ext, {\"k2\"=>\"v2\"}, []]
+CONF
+      assert_not_equal(e.to_s, e.inspect)
+      assert_equal(dump.chomp, e.inspect)
+    end
+  end
+
+  sub_test_case 'for sections which has secret parameter' do
+    setup do
+      @type_lookup = ->(type){ Fluent::Configurable.lookup_type(type) }
+      p1 = Fluent::Config::ConfigureProxy.new(:match, type_lookup: @type_lookup)
+      p1.config_param :str1, :string
+      p1.config_param :str2, :string, secret: true
+      p1.config_param :enum1, :enum, list: [:a, :b, :c]
+      p1.config_param :enum2, :enum, list: [:a, :b, :c], secret: true
+      p1.config_param :bool1, :bool
+      p1.config_param :bool2, :bool, secret: true
+      p1.config_param :int1, :integer
+      p1.config_param :int2, :integer, secret: true
+      p1.config_param :float1, :float
+      p1.config_param :float2, :float, secret: true
+      p2 = Fluent::Config::ConfigureProxy.new(:match, type_lookup: @type_lookup)
+      p2.config_param :size1, :size
+      p2.config_param :size2, :size, secret: true
+      p2.config_param :time1, :time
+      p2.config_param :time2, :time, secret: true
+      p2.config_param :array1, :array
+      p2.config_param :array2, :array, secret: true
+      p2.config_param :hash1, :hash
+      p2.config_param :hash2, :hash, secret: true
+      p1.config_section :mysection do
+        config_param :str1, :string
+        config_param :str2, :string, secret: true
+        config_param :enum1, :enum, list: [:a, :b, :c]
+        config_param :enum2, :enum, list: [:a, :b, :c], secret: true
+        config_param :bool1, :bool
+        config_param :bool2, :bool, secret: true
+        config_param :int1, :integer
+        config_param :int2, :integer, secret: true
+        config_param :float1, :float
+        config_param :float2, :float, secret: true
+        config_param :size1, :size
+        config_param :size2, :size, secret: true
+        config_param :time1, :time
+        config_param :time2, :time, secret: true
+        config_param :array1, :array
+        config_param :array2, :array, secret: true
+        config_param :hash1, :hash
+        config_param :hash2, :hash, secret: true
+      end
+      params = {
+        'str1' => 'aaa', 'str2' => 'bbb', 'enum1' => 'a', 'enum2' => 'b', 'bool1' => 'true', 'bool2' => 'yes',
+        'int1' => '1', 'int2' => '2', 'float1' => '1.0', 'float2' => '0.5', 'size1' => '1k', 'size2' => '1m',
+        'time1' => '5m', 'time2' => '3h', 'array1' => 'a,b,c', 'array2' => 'd,e,f',
+        'hash1' => 'a:1,b:2', 'hash2' => 'a:2,b:4',
+        'unknown1' => 'yay', 'unknown2' => 'boo',
+      }
+      e2 = Fluent::Config::Element.new('mysection', '', params.dup, [])
+      e2.corresponding_proxies << p1.sections.values.first
+      @e = Fluent::Config::Element.new('match', '**', params, [e2])
+      @e.corresponding_proxies << p1
+      @e.corresponding_proxies << p2
+    end
+
+    sub_test_case '#to_masked_element' do
+      test 'returns a new element object which has masked values for secret parameters and elements' do
+        e = @e.to_masked_element
+        assert_equal 'aaa',    e['str1']
+        assert_equal 'xxxxxx', e['str2']
+        assert_equal 'a',      e['enum1']
+        assert_equal 'xxxxxx', e['enum2']
+        assert_equal 'true',   e['bool1']
+        assert_equal 'xxxxxx', e['bool2']
+        assert_equal '1',      e['int1']
+        assert_equal 'xxxxxx', e['int2']
+        assert_equal '1.0',    e['float1']
+        assert_equal 'xxxxxx', e['float2']
+        assert_equal '1k',     e['size1']
+        assert_equal 'xxxxxx', e['size2']
+        assert_equal '5m',     e['time1']
+        assert_equal 'xxxxxx', e['time2']
+        assert_equal 'a,b,c',  e['array1']
+        assert_equal 'xxxxxx', e['array2']
+        assert_equal 'a:1,b:2', e['hash1']
+        assert_equal 'xxxxxx',  e['hash2']
+        assert_equal 'yay', e['unknown1']
+        assert_equal 'boo', e['unknown2']
+        e2 = e.elements.first
+        assert_equal 'aaa',    e2['str1']
+        assert_equal 'xxxxxx', e2['str2']
+        assert_equal 'a',      e2['enum1']
+        assert_equal 'xxxxxx', e2['enum2']
+        assert_equal 'true',   e2['bool1']
+        assert_equal 'xxxxxx', e2['bool2']
+        assert_equal '1',      e2['int1']
+        assert_equal 'xxxxxx', e2['int2']
+        assert_equal '1.0',    e2['float1']
+        assert_equal 'xxxxxx', e2['float2']
+        assert_equal '1k',     e2['size1']
+        assert_equal 'xxxxxx', e2['size2']
+        assert_equal '5m',     e2['time1']
+        assert_equal 'xxxxxx', e2['time2']
+        assert_equal 'a,b,c',  e2['array1']
+        assert_equal 'xxxxxx', e2['array2']
+        assert_equal 'a:1,b:2', e2['hash1']
+        assert_equal 'xxxxxx',  e2['hash2']
+        assert_equal 'yay', e2['unknown1']
+        assert_equal 'boo', e2['unknown2']
+      end
+    end
+
+    sub_test_case '#secret_param?' do
+      test 'returns boolean which shows values of given key will be masked' do
+        assert !@e.secret_param?('str1')
+        assert @e.secret_param?('str2')
+        assert !@e.elements.first.secret_param?('str1')
+        assert @e.elements.first.secret_param?('str2')
+      end
+    end
+
+    sub_test_case '#param_type' do
+      test 'returns parameter type which are registered in corresponding proxy' do
+        assert_equal :string, @e.param_type('str1')
+        assert_equal :string, @e.param_type('str2')
+        assert_equal :enum, @e.param_type('enum1')
+        assert_equal :enum, @e.param_type('enum2')
+        assert_nil @e.param_type('unknown1')
+        assert_nil @e.param_type('unknown2')
+      end
+    end
+
+    # sub_test_case '#dump_value'
+    sub_test_case '#dump_value' do
+      test 'dumps parameter_name and values with leading indentation' do
+        assert_equal "str1 aaa\n", @e.dump_value("str1", @e["str1"], "")
+        assert_equal "str2 xxxxxx\n", @e.dump_value("str2", @e["str2"], "")
+      end
+    end
+  end
+end