fluentd 0.10.62 → 0.12.0.pre.1

data/spec/config/configurable_spec.rb

@@ -0,0 +1,524 @@
+require 'fluent/configurable'
+require 'fluent/config/element'
+require 'fluent/config/section'
+
+module ConfigurableSpec
+  class Base1
+    include Fluent::Configurable
+
+    config_param :node, :string, :default => "node"
+    config_param :flag1, :bool, :default => false
+    config_param :flag2, :bool, :default => true
+
+    config_param :name1, :string
+    config_param :name2, :string
+    config_param :name3, :string, :default => "base1"
+    config_param :name4, :string, :default => "base1"
+
+    def get_all
+      [@node, @flag1, @flag2, @name1, @name2, @name3, @name4]
+    end
+  end
+
+  class Base2 < Base1
+    config_set_default :name2, "base2"
+    config_set_default :name4, "base2"
+    config_param :name5, :string
+    config_param :name6, :string, :default => "base2"
+
+    def get_all
+      ary = super
+      ary + [@name5, @name6]
+    end
+  end
+
+  class Base3 < Base2
+    config_section :node do
+      config_param :name, :string, :default => "node"
+      config_param :type, :string
+    end
+    config_section :branch, required: true, multi: true do
+      config_argument :name, :string
+      config_param :size, :integer, default: 10
+      config_section :leaf, required: false, multi: true do
+        config_param :weight, :integer
+        config_section :worm, param_name: 'worms', multi: true do
+          config_param :type, :string, default: 'ladybird'
+        end
+      end
+    end
+
+    def get_all
+      ary = super
+      ary + [@branch]
+    end
+  end
+
+  class Base4 < Base2
+    config_section :node, param_name: :nodes do
+      config_argument :num, :integer
+      config_param :name, :string, :default => "node"
+      config_param :type, :string, :default => "b4"
+    end
+    config_section :description1, required: false, multi: false do
+      config_argument :note, :string, default: "desc1"
+      config_param :text, :string
+    end
+    config_section :description2, required: true, multi: false do
+      config_argument :note, :string, default: "desc2"
+      config_param :text, :string
+    end
+    config_section :description3, required: true, multi: true do
+      config_argument :note, default: "desc3" do |val|
+        "desc3: #{val}"
+      end
+      config_param :text, :string
+    end
+
+    def get_all
+      ary = super
+      ary + [@nodes, @description1, @description2, @description3]
+    end
+  end
+
+  class Example0
+    include Fluent::Configurable
+
+    config_param :stringvalue, :string
+    config_param :boolvalue, :bool
+    config_param :integervalue, :integer
+    config_param :sizevalue, :size
+    config_param :timevalue, :time
+    config_param :floatvalue, :float
+    config_param :hashvalue, :hash
+    config_param :arrayvalue, :array
+  end
+
+  class Example1
+    include Fluent::Configurable
+
+    config_param :name, :string, alias: :fullname
+    config_param :bool, :bool, alias: :flag
+    config_section :detail, required: true, multi: false, alias: "information" do
+      config_param :address, :string
+    end
+
+    def get_all
+      [@name, @detail]
+    end
+  end
+end
+
+describe Fluent::Configurable do
+  context 'class defined without config_section' do
+    describe '#initialize' do
+      it 'create instance methods and default values by config_param and config_set_default' do
+        obj1 = ConfigurableSpec::Base1.new
+        expect(obj1.node).to eql("node")
+        expect(obj1.flag1).to eq(false)
+        expect(obj1.flag2).to eq(true)
+        expect(obj1.name1).to be_nil
+        expect(obj1.name2).to be_nil
+        expect(obj1.name3).to eql("base1")
+        expect(obj1.name4).to eql("base1")
+      end
+
+      it 'create instance methods and default values overwritten by sub class definition' do
+        obj2 = ConfigurableSpec::Base2.new
+        expect(obj2.node).to eql("node")
+        expect(obj2.flag1).to eq(false)
+        expect(obj2.flag2).to eq(true)
+        expect(obj2.name1).to be_nil
+        expect(obj2.name2).to eql("base2")
+        expect(obj2.name3).to eql("base1")
+        expect(obj2.name4).to eql("base2")
+        expect(obj2.name5).to be_nil
+        expect(obj2.name6).to eql("base2")
+      end
+    end
+
+    describe '#configure' do
+      it 'returns configurable object itself' do
+        b2 = ConfigurableSpec::Base2.new
+        expect(b2.configure({"name1" => "t1", "name5" => "t5"})).to be_a(ConfigurableSpec::Base2)
+      end
+
+      it 'raise errors without any specifications for param without defaults' do
+        b2 = ConfigurableSpec::Base2.new
+        expect{ b2.configure({}) }.to raise_error(Fluent::ConfigError)
+        expect{ b2.configure({"name1" => "t1"}) }.to raise_error(Fluent::ConfigError)
+        expect{ b2.configure({"name5" => "t5"}) }.to raise_error(Fluent::ConfigError)
+        expect{ b2.configure({"name1" => "t1", "name5" => "t5"}) }.not_to raise_error()
+
+        expect(b2.get_all).to eql(["node", false, true, "t1", "base2", "base1", "base2", "t5", "base2"])
+      end
+
+      it 'can configure bool values' do
+        b2a = ConfigurableSpec::Base2.new
+        expect{ b2a.configure({"flag1" => "true", "flag2" => "yes", "name1" => "t1", "name5" => "t5"}) }.not_to raise_error()
+        expect(b2a.flag1).to eq(true)
+        expect(b2a.flag2).to eq(true)
+
+        b2b = ConfigurableSpec::Base2.new
+        expect{ b2b.configure({"flag1" => false, "flag2" => "no", "name1" => "t1", "name5" => "t5"}) }.not_to raise_error()
+        expect(b2b.flag1).to eq(false)
+        expect(b2b.flag2).to eq(false)
+      end
+
+      it 'overwrites values of defaults' do
+        b2 = ConfigurableSpec::Base2.new
+        b2.configure({"name1" => "t1", "name2" => "t2", "name3" => "t3", "name4" => "t4", "name5" => "t5"})
+        expect(b2.name1).to eql("t1")
+        expect(b2.name2).to eql("t2")
+        expect(b2.name3).to eql("t3")
+        expect(b2.name4).to eql("t4")
+        expect(b2.name5).to eql("t5")
+        expect(b2.name6).to eql("base2")
+
+        expect(b2.get_all).to eql(["node", false, true, "t1", "t2", "t3", "t4", "t5", "base2"])
+      end
+    end
+  end
+
+  context 'class defined with config_section' do
+    describe '#initialize' do
+      it 'create instance methods and default values as nil for params from config_section specified as non-multi' do
+        b4 = ConfigurableSpec::Base4.new
+        expect(b4.description1).to be_nil
+        expect(b4.description2).to be_nil
+      end
+
+      it 'create instance methods and default values as [] for params from config_section specified as multi' do
+        b4 = ConfigurableSpec::Base4.new
+        expect(b4.description3).to eql([])
+      end
+
+      it 'overwrite base class definition by config_section of sub class definition' do
+        b3 = ConfigurableSpec::Base3.new
+        expect(b3.node).to eql([])
+      end
+
+      it 'create instance methods and default values by param_name' do
+        b4 = ConfigurableSpec::Base4.new
+        expect(b4.nodes).to eql([])
+        expect(b4.node).to eql("node")
+      end
+
+      it 'create non-required and multi without any specifications' do
+        b3 = ConfigurableSpec::Base3.new
+        expect(b3.class.merged_configure_proxy.sections[:node].required?).to be false
+        expect(b3.class.merged_configure_proxy.sections[:node].multi?).to be true
+      end
+    end
+
+    describe '#configure' do
+      def e(name, arg = '', attrs = {}, elements = [])
+        attrs_str_keys = {}
+        attrs.each{|key, value| attrs_str_keys[key.to_s] = value }
+        Fluent::Config::Element.new(name, arg, attrs_str_keys, elements)
+      end
+
+      BASE_ATTRS = {
+        "name1" => "1", "name2" => "2", "name3" => "3",
+        "name4" => "4", "name5" => "5", "name6" => "6",
+      }
+      it 'checks required subsections' do
+        b3 = ConfigurableSpec::Base3.new
+        # branch sections required
+        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [])) }.to raise_error(Fluent::ConfigError)
+
+        # branch argument required
+        msg = "'<branch ARG>' section requires argument, in section branch"
+        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [e('branch', '')])) }.to raise_error(Fluent::ConfigError, msg)
+
+        # leaf is not required
+        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [e('branch', 'branch_name')])) }.not_to raise_error()
+
+        # leaf weight required
+        msg = "'weight' parameter is required, in section branch > leaf"
+        branch1 = e('branch', 'branch_name', {size: 1}, [e('leaf', '10', {weight: 1})])
+        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [branch1])) }.not_to raise_error()
+        branch2 = e('branch', 'branch_name', {size: 1}, [e('leaf', '20')])
+        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [branch1, branch2])) }.to raise_error(Fluent::ConfigError, msg)
+        branch3 = e('branch', 'branch_name', {size: 1}, [e('leaf', '10', {weight: 3}), e('leaf', '20')])
+        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [branch3])) }.to raise_error(Fluent::ConfigError, msg)
+
+        ### worm not required
+
+        b4 = ConfigurableSpec::Base4.new
+
+        d1 = e('description1', '', {text:"d1"})
+        d2 = e('description2', '', {text:"d2"})
+        d3 = e('description3', '', {text:"d3"})
+        expect{ b4.configure(e('ROOT', '', BASE_ATTRS, [d1.dup, d2.dup, d3.dup])) }.not_to raise_error()
+
+        # description1 cannot be specified 2 or more
+        msg = "'<description1>' section cannot be written twice or more"
+        expect{ b4.configure(e('ROOT', '', BASE_ATTRS, [d1.dup, d2.dup, d1.dup, d3.dup])) }.to raise_error(Fluent::ConfigError, msg)
+
+        # description2 cannot be specified 2 or more
+        msg = "'<description2>' section cannot be written twice or more"
+        expect{ b4.configure(e('ROOT', '', BASE_ATTRS, [d1.dup, d2.dup, d3.dup, d2.dup])) }.to raise_error(Fluent::ConfigError, msg)
+
+        # description3 can be specified 2 or more
+        expect{ b4.configure(e('ROOT', '', BASE_ATTRS, [d1.dup, d2.dup, d3.dup, d3.dup])) }.not_to raise_error()
+      end
+
+      it 'constructs confuguration object tree for Base3' do
+        conf = e(
+          'ROOT',
+          '',
+          BASE_ATTRS,
+          [
+            e('node', '', {type:"1"}), e('node', '', {name:"node2",type:"2"}),
+            e('branch', 'b1.*', {}, []),
+            e('branch',
+              'b2.*',
+              {size: 5},
+              [
+                e('leaf', 'THIS IS IGNORED', {weight: 55}, []),
+                e('leaf', 'THIS IS IGNORED', {weight: 50}, [ e('worm', '', {}) ]),
+                e('leaf', 'THIS IS IGNORED', {weight: 50}, [ e('worm', '', {type:"w1"}), e('worm', '', {type:"w2"}) ]),
+              ]
+            ),
+            e('branch',
+              'b3.*',
+              {size: "503"},
+              [
+                e('leaf', 'THIS IS IGNORED', {weight: 55}, []),
+              ]
+            )
+          ],
+        )
+        b3 = ConfigurableSpec::Base3.new.configure(conf)
+
+        expect(b3.node).not_to eql("node") # overwritten
+
+        expect(b3.name1).to eql("1")
+        expect(b3.name2).to eql("2")
+        expect(b3.name3).to eql("3")
+        expect(b3.name4).to eql("4")
+        expect(b3.name5).to eql("5")
+        expect(b3.name6).to eql("6")
+
+        expect(b3.node).to be_a(Array)
+        expect(b3.node.size).to eql(2)
+
+        expect(b3.node[0].name).to eql("node")
+        expect(b3.node[0].type).to eql("1")
+        expect(b3.node[0][:type]).to eq(b3.node[0].type)
+        expect(b3.node[1].name).to eql("node2")
+        expect(b3.node[1].type).to eql("2")
+        expect(b3.node[1][:type]).to eq(b3.node[1].type)
+
+        expect(b3.branch).to be_a(Array)
+        expect(b3.branch.size).to eql(3)
+
+        expect(b3.branch[0].name).to eql('b1.*')
+        expect(b3.branch[0].size).to eql(10)
+        expect(b3.branch[0].leaf).to eql([])
+
+        expect(b3.branch[1].name).to eql('b2.*')
+        expect(b3.branch[1].size).to eql(5)
+        expect(b3.branch[1].leaf.size).to eql(3)
+        expect(b3.branch[1][:leaf]).to eq(b3.branch[1].leaf)
+
+        expect(b3.branch[1].leaf[0].weight).to eql(55)
+        expect(b3.branch[1].leaf[0].worms.size).to eql(0)
+
+        expect(b3.branch[1].leaf[1].weight).to eql(50)
+        expect(b3.branch[1].leaf[1].worms.size).to eql(1)
+        expect(b3.branch[1].leaf[1].worms[0].type).to eql("ladybird")
+
+        expect(b3.branch[1].leaf[2].weight).to eql(50)
+        expect(b3.branch[1].leaf[2].worms.size).to eql(2)
+        expect(b3.branch[1].leaf[2].worms[0].type).to eql("w1")
+        expect(b3.branch[1].leaf[2].worms[1].type).to eql("w2")
+
+        expect(b3.branch[2].name).to eql('b3.*')
+        expect(b3.branch[2].size).to eql(503)
+        expect(b3.branch[2].leaf.size).to eql(1)
+        expect(b3.branch[2].leaf[0].weight).to eql(55)
+      end
+
+      it 'constructs confuguration object tree for Base4' do
+        conf = e(
+          'ROOT',
+          '',
+          BASE_ATTRS,
+          [
+            e('node', '1', {type:"1"}), e('node', '2', {name:"node2"}),
+            e('description3', '', {text:"dddd3-1"}),
+            e('description2', 'd-2', {text:"dddd2"}),
+            e('description1', '', {text:"dddd1"}),
+            e('description3', 'd-3', {text:"dddd3-2"}),
+            e('description3', 'd-3a', {text:"dddd3-3"}),
+            e('node', '4', {type:"four"}),
+          ],
+        )
+        b4 = ConfigurableSpec::Base4.new.configure(conf)
+
+        expect(b4.node).to eql("node")
+
+        expect(b4.name1).to eql("1")
+        expect(b4.name2).to eql("2")
+        expect(b4.name3).to eql("3")
+        expect(b4.name4).to eql("4")
+        expect(b4.name5).to eql("5")
+        expect(b4.name6).to eql("6")
+
+        expect(b4.nodes).to be_a(Array)
+        expect(b4.nodes.size).to eql(3)
+        expect(b4.nodes[0].num).to eql(1)
+        expect(b4.nodes[0].name).to eql("node")
+        expect(b4.nodes[0].type).to eql("1")
+        expect(b4.nodes[1].num).to eql(2)
+        expect(b4.nodes[1].name).to eql("node2")
+        expect(b4.nodes[1].type).to eql("b4")
+        expect(b4.nodes[2].num).to eql(4)
+        expect(b4.nodes[2].name).to eql("node")
+        expect(b4.nodes[2].type).to eql("four")
+
+            # e('description3', '', {text:"dddd3-1"}),
+            # e('description3', 'd-3', {text:"dddd3-2"}),
+            # e('description3', 'd-3a', {text:"dddd3-3"}),
+
+        expect(b4.description1).to be_a(Fluent::Config::Section)
+        expect(b4.description1.note).to eql("desc1")
+        expect(b4.description1.text).to eql("dddd1")
+
+        expect(b4.description2).to be_a(Fluent::Config::Section)
+        expect(b4.description2.note).to eql("d-2")
+        expect(b4.description2.text).to eql("dddd2")
+
+        expect(b4.description3).to be_a(Array)
+        expect(b4.description3.size).to eql(3)
+        expect(b4.description3[0].note).to eql('desc3')
+        expect(b4.description3[0].text).to eql('dddd3-1')
+        expect(b4.description3[1].note).to eql('desc3: d-3')
+        expect(b4.description3[1].text).to eql('dddd3-2')
+        expect(b4.description3[2].note).to eql('desc3: d-3a')
+        expect(b4.description3[2].text).to eql('dddd3-3')
+      end
+
+      it 'checks missing of specifications' do
+        conf0 = e('ROOT', '', {}, [])
+        ex01 = ConfigurableSpec::Example0.new
+        expect { ex01.configure(conf0) }.to raise_error(Fluent::ConfigError)
+
+        complete = {
+          "stringvalue" => "s1", "boolvalue" => "yes", "integervalue" => "10",
+          "sizevalue" => "10m", "timevalue" => "100s", "floatvalue" => "1.001",
+          "hashvalue" => '{"foo":1, "bar":2}',
+          "arrayvalue" => '[1,"ichi"]',
+        }
+
+        checker = lambda {|conf| ConfigurableSpec::Example0.new.configure(conf) }
+
+        expect { checker.call(complete) }.not_to raise_error()
+        expect { checker.call(complete.reject{|k,v| k == "stringvalue" }) }.to raise_error(Fluent::ConfigError)
+        expect { checker.call(complete.reject{|k,v| k == "boolvalue"   }) }.to raise_error(Fluent::ConfigError)
+        expect { checker.call(complete.reject{|k,v| k == "integervalue"}) }.to raise_error(Fluent::ConfigError)
+        expect { checker.call(complete.reject{|k,v| k == "sizevalue"   }) }.to raise_error(Fluent::ConfigError)
+        expect { checker.call(complete.reject{|k,v| k == "timevalue"   }) }.to raise_error(Fluent::ConfigError)
+        expect { checker.call(complete.reject{|k,v| k == "floatvalue"  }) }.to raise_error(Fluent::ConfigError)
+        expect { checker.call(complete.reject{|k,v| k == "hashvalue"   }) }.to raise_error(Fluent::ConfigError)
+        expect { checker.call(complete.reject{|k,v| k == "arrayvalue"  }) }.to raise_error(Fluent::ConfigError)
+      end
+
+      it 'accepts configuration values as string representation' do
+        conf = {
+          "stringvalue" => "s1", "boolvalue" => "yes", "integervalue" => "10",
+          "sizevalue" => "10m", "timevalue" => "10m", "floatvalue" => "1.001",
+          "hashvalue" => '{"foo":1, "bar":2}',
+          "arrayvalue" => '[1,"ichi"]',
+        }
+        ex = ConfigurableSpec::Example0.new.configure(conf)
+        expect(ex.stringvalue).to eq("s1")
+        expect(ex.boolvalue).to equal(true)
+        expect(ex.integervalue).to eq(10)
+        expect(ex.sizevalue).to eq(10 * 1024 * 1024)
+        expect(ex.timevalue).to eq(10 * 60)
+        expect(ex.floatvalue).to eq(1.001)
+        expect(ex.hashvalue).to eq({"foo" => 1, "bar" => 2})
+        expect(ex.arrayvalue).to eq([1, "ichi"])
+      end
+
+      it 'accepts configuration values as ruby value representation (especially for DSL)' do
+        conf = {
+          "stringvalue" => "s1", "boolvalue" => true, "integervalue" => 10,
+          "sizevalue" => 10 * 1024 * 1024, "timevalue" => 10 * 60, "floatvalue" => 1.001,
+          "hashvalue" => {"foo" => 1, "bar" => 2},
+          "arrayvalue" => [1,"ichi"],
+        }
+        ex = ConfigurableSpec::Example0.new.configure(conf)
+        expect(ex.stringvalue).to eq("s1")
+        expect(ex.boolvalue).to equal(true)
+        expect(ex.integervalue).to eq(10)
+        expect(ex.sizevalue).to eq(10 * 1024 * 1024)
+        expect(ex.timevalue).to eq(10 * 60)
+        expect(ex.floatvalue).to eq(1.001)
+        expect(ex.hashvalue).to eq({"foo" => 1, "bar" => 2})
+        expect(ex.arrayvalue).to eq([1, "ichi"])
+      end
+
+      it 'gets both of true(yes) and false(no) for bool value parameter' do
+        conf = {
+          "stringvalue" => "s1", "integervalue" => 10,
+          "sizevalue" => 10 * 1024 * 1024, "timevalue" => 10 * 60, "floatvalue" => 1.001,
+          "hashvalue" => {"foo" => 1, "bar" => 2},
+          "arrayvalue" => [1,"ichi"],
+        }
+        ex0 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => "true"}))
+        expect(ex0.boolvalue).to equal(true)
+
+        ex1 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => "yes"}))
+        expect(ex1.boolvalue).to equal(true)
+
+        ex2 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => true}))
+        expect(ex2.boolvalue).to equal(true)
+
+        ex3 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => "false"}))
+        expect(ex3.boolvalue).to equal(false)
+
+        ex4 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => "no"}))
+        expect(ex4.boolvalue).to equal(false)
+
+        ex5 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => false}))
+        expect(ex5.boolvalue).to equal(false)
+      end
+    end
+  end
+
+  context 'class defined with config_param/config_section having :alias' do
+    describe '#initialize' do
+      it 'does not create methods for alias' do
+        ex1 = ConfigurableSpec::Example1.new
+        expect { ex1.name }.not_to raise_error()
+        expect { ex1.fullname }.to raise_error(NoMethodError)
+        expect { ex1.bool }.not_to raise_error()
+        expect { ex1.flag }.to raise_error(NoMethodError)
+        expect { ex1.detail }.not_to raise_error()
+        expect { ex1.information}.to raise_error(NoMethodError)
+      end
+    end
+
+    describe '#configure' do
+      def e(name, arg = '', attrs = {}, elements = [])
+        attrs_str_keys = {}
+        attrs.each{|key, value| attrs_str_keys[key.to_s] = value }
+        Fluent::Config::Element.new(name, arg, attrs_str_keys, elements)
+      end
+
+      it 'provides accessible data for alias attribute keys' do
+        ex1 = ConfigurableSpec::Example1.new
+        ex1.configure(e('ROOT', '', {"fullname" => "foo bar", "bool" => false}, [e('information', '', {"address" => "Mountain View 0"})]))
+        expect(ex1.name).to eql("foo bar")
+        expect(ex1.bool).not_to be_nil
+        expect(ex1.bool).to be_falsy
+        expect(ex1.detail).not_to be_nil
+        expect(ex1.detail.address).to eql("Mountain View 0")
+      end
+    end
+  end
+end