fluentd 0.12.40 → 0.14.0

data/test/config/test_configure_proxy.rb

@@ -3,15 +3,21 @@ require 'fluent/config/configure_proxy'
 
 module Fluent::Config
   class TestConfigureProxy < ::Test::Unit::TestCase
+    setup do
+      @type_lookup = ->(type) { Fluent::Configurable.lookup_type(type) }
+    end
+
     sub_test_case 'to generate a instance' do
       sub_test_case '#initialize' do
         test 'has default values' do
-          proxy = Fluent::Config::ConfigureProxy.new('section')
+          proxy = Fluent::Config::ConfigureProxy.new('section', type_lookup: @type_lookup)
           assert_equal(:section, proxy.name)
 
-          proxy = Fluent::Config::ConfigureProxy.new(:section)
+          proxy = Fluent::Config::ConfigureProxy.new(:section, type_lookup: @type_lookup)
           assert_equal(:section, proxy.name)
-          assert_equal(:section, proxy.param_name)
+          assert_nil(proxy.param_name)
+          assert_equal(:section, proxy.variable_name)
+          assert_nil(proxy.init)
           assert_nil(proxy.required)
           assert_false(proxy.required?)
           assert_nil(proxy.multi)
@@ -19,85 +25,196 @@ module Fluent::Config
         end
 
         test 'can specify param_name/required/multi with optional arguments' do
-          proxy = Fluent::Config::ConfigureProxy.new(:section, param_name: 'sections', required: false, multi: true)
+          proxy = Fluent::Config::ConfigureProxy.new(:section, param_name: 'sections', init: true, required: false, multi: true, type_lookup: @type_lookup)
           assert_equal(:section, proxy.name)
           assert_equal(:sections, proxy.param_name)
+          assert_equal(:sections, proxy.variable_name)
           assert_false(proxy.required)
           assert_false(proxy.required?)
           assert_true(proxy.multi)
           assert_true(proxy.multi?)
 
-          proxy = Fluent::Config::ConfigureProxy.new(:section, param_name: :sections, required: true, multi: false)
+          proxy = Fluent::Config::ConfigureProxy.new(:section, param_name: :sections, init: false, required: true, multi: false, type_lookup: @type_lookup)
           assert_equal(:section, proxy.name)
           assert_equal(:sections, proxy.param_name)
+          assert_equal(:sections, proxy.variable_name)
           assert_true(proxy.required)
           assert_true(proxy.required?)
           assert_false(proxy.multi)
           assert_false(proxy.multi?)
         end
+        test 'raise error if both of init and required are true' do
+          assert_raise "init and required are exclusive" do
+            Fluent::Config::ConfigureProxy.new(:section, init: true, required: true, type_lookup: @type_lookup)
+          end
+        end
       end
 
       sub_test_case '#merge' do
         test 'generate a new instance which values are overwritten by the argument object' do
-          proxy = p1 = Fluent::Config::ConfigureProxy.new(:section)
+          proxy = p1 = Fluent::Config::ConfigureProxy.new(:section, type_lookup: @type_lookup)
           assert_equal(:section, proxy.name)
-          assert_equal(:section, proxy.param_name)
+          assert_nil(proxy.param_name)
+          assert_equal(:section, proxy.variable_name)
+          assert_nil(proxy.init)
           assert_nil(proxy.required)
           assert_false(proxy.required?)
           assert_nil(proxy.multi)
           assert_true(proxy.multi?)
+          assert_nil(proxy.configured_in_section)
 
-          p2 = Fluent::Config::ConfigureProxy.new(:section, param_name: :sections, required: true, multi: false)
+          p2 = Fluent::Config::ConfigureProxy.new(:section, init: false, required: true, multi: false, type_lookup: @type_lookup)
           proxy = p1.merge(p2)
           assert_equal(:section, proxy.name)
-          assert_equal(:sections, proxy.param_name)
+          assert_nil(proxy.param_name)
+          assert_equal(:section, proxy.variable_name)
+          assert_false(proxy.init)
+          assert_false(proxy.init?)
           assert_true(proxy.required)
           assert_true(proxy.required?)
           assert_false(proxy.multi)
           assert_false(proxy.multi?)
+          assert_nil(proxy.configured_in_section)
         end
 
         test 'does not overwrite with argument object without any specifications of required/multi' do
-          p1 = Fluent::Config::ConfigureProxy.new(:section1)
-          p2 = Fluent::Config::ConfigureProxy.new(:section2, param_name: :sections, required: true, multi: false)
-          p3 = Fluent::Config::ConfigureProxy.new(:section3)
+          p1 = Fluent::Config::ConfigureProxy.new(:section1, param_name: :sections, type_lookup: @type_lookup)
+          p1.configured_in_section = :subsection
+          p2 = Fluent::Config::ConfigureProxy.new(:section2, init: false, required: true, multi: false, type_lookup: @type_lookup)
+          p3 = Fluent::Config::ConfigureProxy.new(:section3, type_lookup: @type_lookup)
           proxy = p1.merge(p2).merge(p3)
-          assert_equal(:section3, proxy.name)
-          assert_equal(:section3, proxy.param_name)
+          assert_equal(:section1, proxy.name)
+          assert_equal(:sections, proxy.param_name)
+          assert_equal(:sections, proxy.variable_name)
+          assert_false(proxy.init)
+          assert_false(proxy.init?)
           assert_true(proxy.required)
           assert_true(proxy.required?)
           assert_false(proxy.multi)
           assert_false(proxy.multi?)
+          assert_equal :subsection, proxy.configured_in_section
+        end
+      end
+
+      sub_test_case '#overwrite_defaults' do
+        test 'overwrites only defaults with others defaults' do
+          type_lookup = ->(type) { Fluent::Configurable.lookup_type(type) }
+          p1 = Fluent::Config::ConfigureProxy.new(:mychild, type_lookup: type_lookup)
+          p1.configured_in_section = :child
+          p1.config_param(:k1a, :string)
+          p1.config_param(:k1b, :string)
+          p1.config_param(:k2a, :integer, default: 0)
+          p1.config_param(:k2b, :integer, default: 0)
+          p1.config_section(:sub1) do
+            config_param :k3, :time, default: 30
+          end
+
+          p0 = Fluent::Config::ConfigureProxy.new(:myparent, type_lookup: type_lookup)
+          p0.config_section(:child) do
+            config_set_default :k1a, "v1a"
+            config_param :k1b, :string, default: "v1b"
+            config_set_default :k2a, 21
+            config_param :k2b, :integer, default: 22
+            config_section :sub1 do
+              config_set_default :k3, 60
+            end
+          end
+
+          p1.overwrite_defaults(p0.sections[:child])
+
+          assert_equal "v1a", p1.defaults[:k1a]
+          assert_equal "v1b", p1.defaults[:k1b]
+          assert_equal 21, p1.defaults[:k2a]
+          assert_equal 22, p1.defaults[:k2b]
+          assert_equal 60, p1.sections[:sub1].defaults[:k3]
+        end
+      end
+
+      sub_test_case '#configured_in' do
+        test 'sets a section name which have configuration parameters of target plugin in owners configuration' do
+          proxy = Fluent::Config::ConfigureProxy.new(:section, type_lookup: @type_lookup)
+          proxy.configured_in(:mysection)
+          assert_equal :mysection, proxy.configured_in_section
+        end
+
+        test 'do not permit to be called twice' do
+          proxy = Fluent::Config::ConfigureProxy.new(:section, type_lookup: @type_lookup)
+          proxy.configured_in(:mysection)
+          assert_raise(ArgumentError) { proxy.configured_in(:myothersection) }
         end
       end
 
       sub_test_case '#config_param / #config_set_default / #config_argument' do
+        setup do
+          @proxy = Fluent::Config::ConfigureProxy.new(:section, type_lookup: @type_lookup)
+        end
+
         test 'does not permit config_set_default for param w/ :default option' do
-          proxy = Fluent::Config::ConfigureProxy.new(:section)
-          proxy.config_param(:name, :string, default: "name1")
-          assert_raise(ArgumentError) { proxy.config_set_default(:name, "name2") }
+          @proxy.config_param(:name, :string, default: "name1")
+          assert_raise(ArgumentError) { @proxy.config_set_default(:name, "name2") }
         end
 
         test 'does not permit default value specification twice' do
-          proxy = Fluent::Config::ConfigureProxy.new(:section)
-          proxy.config_param(:name, :string)
-          proxy.config_set_default(:name, "name1")
-          assert_raise(ArgumentError) { proxy.config_set_default(:name, "name2") }
+          @proxy.config_param(:name, :string)
+          @proxy.config_set_default(:name, "name1")
+          assert_raise(ArgumentError) { @proxy.config_set_default(:name, "name2") }
         end
 
         test 'does not permit default value specification twice, even on config_argument' do
-          proxy = Fluent::Config::ConfigureProxy.new(:section)
-          proxy.config_param(:name, :string)
-          proxy.config_set_default(:name, "name1")
+          @proxy.config_param(:name, :string)
+          @proxy.config_set_default(:name, "name1")
+
+          @proxy.config_argument(:name)
+          assert_raise(ArgumentError) { @proxy.config_argument(:name, default: "name2") }
+        end
+      end
+
+      sub_test_case '#config_param without default values cause error if section is configured as init:true' do
+        setup do
+          @proxy = Fluent::Config::ConfigureProxy.new(:section, type_lookup: @type_lookup)
+        end
 
-          proxy.config_argument(:name)
-          assert_raise(ArgumentError) { proxy.config_argument(:name, default: "name2") }
+        test 'with simple config_param with default value' do
+          assert_nothing_raised do
+            @proxy.config_section :subsection, init: true do
+              config_param :param1, :integer, default: 1
+            end
+          end
+        end
+        test 'with simple config_param without default value' do
+          assert_raise ArgumentError do
+            @proxy.config_section :subsection, init: true do
+              config_param :param1, :integer
+            end
+          end
+        end
+        test 'with config_param with config_set_default' do
+          assert_nothing_raised do
+            @proxy.config_section :subsection, init: true do
+              config_param :param1, :integer
+              config_set_default :param1, 1
+            end
+          end
+        end
+        test 'with config_argument' do
+          assert_raise ArgumentError do
+            @proxy.config_section :subsection, init: true do
+              config_argument :param0, :string
+            end
+          end
+        end
+        test 'with config_argument with default value' do
+          assert_nothing_raised do
+            @proxy.config_section :subsection, init: true do
+              config_argument :param0, :string, default: ''
+            end
+          end
         end
       end
 
       sub_test_case '#config_set_desc' do
         setup do
-          @proxy = Fluent::Config::ConfigureProxy.new(:section)
+          @proxy = Fluent::Config::ConfigureProxy.new(:section, type_lookup: @type_lookup)
         end
 
         test 'does not permit description specification twice w/ :desc option' do
@@ -114,7 +231,7 @@ module Fluent::Config
 
       sub_test_case '#desc' do
         setup do
-          @proxy = Fluent::Config::ConfigureProxy.new(:section)
+          @proxy = Fluent::Config::ConfigureProxy.new(:section, type_lookup: @type_lookup)
         end
 
         test 'permit to specify description twice' do
@@ -134,7 +251,7 @@ module Fluent::Config
 
       sub_test_case '#dump' do
         setup do
-          @proxy = Fluent::Config::ConfigureProxy.new(:section)
+          @proxy = Fluent::Config::ConfigureProxy.new(:section, type_lookup: @type_lookup)
         end
 
         test 'empty proxy' do

data/test/config/test_dsl.rb

@@ -2,66 +2,6 @@ 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"
@@ -117,14 +57,6 @@ source {
 }
 ]
 
-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 {
 }
@@ -142,9 +74,6 @@ match('aa','bb'){
 DSL_CONFIG_WRONG_SYNTAX3 = %q[
 match('aa','bb')
 ]
-DSL_CONFIG_WRONG_SYNTAX4 = %q[
-include
-]
 
 module Fluent::Config
   class TestDSLParser < ::Test::Unit::TestCase
@@ -229,116 +158,10 @@ module Fluent::Config
       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
-          root = Fluent::Config::DSL::Parser.parse(DSL_CONFIG_RETURNS_NON_ELEMENT, 'dsl_config_returns_non_element.rb')
+          Fluent::Config::DSL::Parser.parse(DSL_CONFIG_RETURNS_NON_ELEMENT, 'dsl_config_returns_non_element.rb')
         end
       end
     end
@@ -347,9 +170,8 @@ module Fluent::Config
       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') }
+          assert_raise(ArgumentError) { Fluent::Config::DSL::Parser.parse(DSL_CONFIG_WRONG_SYNTAX2, 'dsl_config_wrong_syntax1') }
+          assert_raise(ArgumentError) { Fluent::Config::DSL::Parser.parse(DSL_CONFIG_WRONG_SYNTAX3, 'dsl_config_wrong_syntax1') }
         end
       end
     end