fluentd 0.12.40 → 0.14.0

data/test/config/test_element.rb

@@ -0,0 +1,274 @@
+require_relative '../helper'
+require 'fluent/config/element'
+
+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 'Most test' do
+    test 'should be written' do
+      pend 'TODO'
+    end
+  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
+end

data/test/config/test_literal_parser.rb

@@ -105,8 +105,8 @@ module Fluent::Config
       test('"\\.t"') { assert_text_parsed_as(".t", '"\\.t"') }
       test('"\\$t"') { assert_text_parsed_as("$t", '"\\$t"') }
       test('"\\"') { assert_text_parsed_as("#t", '"\\#t"') }
-      test('"\\0"') { assert_text_parsed_as("\0", '"\\0"') }
       test('"\\z"') { assert_parse_error('"\\z"') }  # unknown escaped character
+      test('"\\0"') { assert_parse_error('"\\0"') }  # unknown escaped character
       test('"\\1"') { assert_parse_error('"\\1"') }  # unknown escaped character
       test('"t') { assert_parse_error('"t') }  # non-terminated quoted character
       test("\"t\nt\"") { assert_text_parsed_as("t\nt", "\"t\nt\"" ) } # multiline string

data/test/config/test_section.rb

@@ -24,7 +24,7 @@ module Fluent::Config
               name: 'tagomoris',
               age: 34,
               send: 'email',
-              class: 'normal',
+              klass: 'normal',
               keys: 5,
             }
             s1 = Fluent::Config::Section.new(hash)
@@ -32,17 +32,53 @@ module Fluent::Config
             assert_equal("tagomoris", s1[:name])
             assert_equal(34, s1[:age])
             assert_equal("email", s1[:send])
-            assert_equal("normal", s1[:class])
+            assert_equal("normal", s1[:klass])
             assert_equal(5, s1[:keys])
 
             assert_equal("tagomoris", s1.name)
             assert_equal(34, s1.age)
             assert_equal("email", s1.send)
-            assert_equal("normal", s1.class)
+            assert_equal("normal", s1.klass)
             assert_equal(5, s1.keys)
 
             assert_raise(NoMethodError) { s1.dup }
           end
+
+          test 'creates object which contains specified hash object itself, including fields with at prefix' do
+            hash = {
+              name: 'tagomoris',
+              age: 34,
+              send: 'email',
+              klass: 'normal',
+              keys: 5,
+            }
+            hash['@id'.to_sym] = 'myid'
+
+            s1 = Fluent::Config::Section.new(hash)
+            assert_equal('myid', s1['@id'])
+            assert_equal('myid', s1['@id'.to_sym])
+            assert_equal('myid', s1.__send__('@id'.to_sym))
+          end
+
+          test 'creates object and config element which corresponds to section object itself' do
+            hash = {
+              name: 'tagomoris',
+              age: 34,
+              send: 'email',
+              klass: 'normal',
+              keys: 5,
+            }
+            hash['@id'.to_sym] = 'myid'
+            conf = config_element('section', '', {'name' => 'tagomoris', 'age' => 34, 'send' => 'email', 'klass' => 'normal', 'keys' => 5})
+            s2 = Fluent::Config::Section.new(hash, conf)
+            assert s2.corresponding_config_element.is_a?(Fluent::Config::Element)
+          end
+        end
+
+        sub_test_case '#class' do
+          test 'returns class constant' do
+            assert_equal Fluent::Config::Section, Fluent::Config::Section.new({}).class
+          end
         end
 
         sub_test_case '#object_id' do
@@ -61,7 +97,7 @@ module Fluent::Config
               name: 'tagomoris',
               age: 34,
               send: 'email',
-              class: 'normal',
+              klass: 'normal',
               keys: 5,
             }
             s = Fluent::Config::Section.new(hash)
@@ -89,10 +125,10 @@ module Fluent::Config
 
         sub_test_case '#+' do
           test 'can merge 2 sections: argument side is primary, internal hash is newly created' do
-            h1 = {name: "s1", num: 10, class: "A"}
+            h1 = {name: "s1", num: 10, klass: "A"}
             s1 = Fluent::Config::Section.new(h1)
 
-            h2 = {name: "s2", class: "A", num2: "5", num3: "8"}
+            h2 = {name: "s2", klass: "A", num2: "5", num3: "8"}
             s2 = Fluent::Config::Section.new(h2)
             s = s1 + s2
 
@@ -101,11 +137,47 @@ module Fluent::Config
 
             assert_equal("s2", s.name)
             assert_equal(10, s.num)
-            assert_equal("A", s.class)
+            assert_equal("A", s.klass)
             assert_equal("5", s.num2)
             assert_equal("8", s.num3)
           end
         end
+
+        sub_test_case '#to_s' do
+          test '#to_s == #inspect' do
+            h1 = {name: "s1", num: 10, klass: "A"}
+            s1 = Fluent::Config::Section.new(h1)
+
+            assert_equal(s1.to_s, s1.inspect)
+          end
+        end
+
+        data("inspect" => [:inspect, true],
+             "nil?" => [:nil?, true],
+             "to_h" => [:to_h, true],
+             "+" =>   [:+, true],
+             "instance_of?" => [:instance_of?, true],
+             "kind_of?" => [:kind_of?, true],
+             "[]" => [:[], true],
+             "respond_to?" => [:respond_to?, true],
+             "respond_to_missing?" => [:respond_to_missing?, true],
+             "!" => [:!, true],
+             "!=" => [:!=, true],
+             "==" => [:==, true],
+             "equal?" => [:equal?, true],
+             "instance_eval" => [:instance_eval, true],
+             "instance_exec" => [:instance_exec, true],
+             "method_missing" => [:method_missing, false],
+             "singleton_method_added" => [:singleton_method_added, false],
+             "singleton_method_removed" => [:singleton_method_removed, false],
+             "singleton_method_undefined" => [:singleton_method_undefined, false],
+             "no_such_method" => [:no_such_method, false])
+        test '#respond_to?' do |data|
+          method, expected = data
+          h1 = {name: "s1", num: 10, klass: "A"}
+          s1 = Fluent::Config::Section.new(h1)
+          assert_equal(expected, s1.respond_to?(method))
+        end
       end
     end
   end

data/test/config/test_system_config.rb

@@ -20,6 +20,9 @@ module Fluent::Config
       @suppress_config_dump = nil
       @suppress_repeated_stacktrace = nil
       @without_source = nil
+      @emit_error_log_interval = nil
+      @file_permission = nil
+      @dir_permission = nil
     end
   end
 
@@ -48,6 +51,8 @@ module Fluent::Config
       assert_nil(s.instance_variable_get(:@emit_error_log_interval))
       assert_nil(s.instance_variable_get(:@suppress_config_dump))
       assert_nil(s.instance_variable_get(:@without_source))
+      assert_nil(s.instance_variable_get(:@file_permission))
+      assert_nil(s.instance_variable_get(:@dir_permission))
     end
 
     {'log_level' => 'error',
@@ -81,6 +86,8 @@ module Fluent::Config
         assert_nil(s.instance_variable_get(:@emit_error_log_interval))
         assert_nil(s.instance_variable_get(:@suppress_config_dump))
         assert_nil(s.instance_variable_get(:@without_source))
+        assert_nil(s.instance_variable_get(:@file_permission))
+        assert_nil(s.instance_variable_get(:@dir_permission))
       end
     }
 
@@ -95,5 +102,19 @@ module Fluent::Config
       sc.apply(s)
       assert_equal(Fluent::Log::LEVEL_WARN, s.instance_variable_get("@log").level)
     end
+
+    test 'process global overridable variables' do
+      conf = parse_text(<<-EOS)
+        <system>
+          file_permission 0655
+          dir_permission 0765
+        </system>
+      EOS
+      s = FakeSupervisor.new
+      sc = Fluent::SystemConfig.new(conf)
+      sc.apply(s)
+      assert_equal(0655, s.instance_variable_get(:@file_permission))
+      assert_equal(0765, s.instance_variable_get(:@dir_permission))
+    end
   end
 end