fluentd 0.14.12-x64-mingw32 → 0.14.13-x64-mingw32

data/templates/new_gem/test/plugin/test_input.rb.erb

@@ -0,0 +1,18 @@
+require "helper"
+require "fluent/plugin/<%= plugin_filename %>"
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  setup do
+    Fluent::Test.setup
+  end
+
+  test "failure" do
+    flunk
+  end
+
+  private
+
+  def create_driver(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::<%= class_name %>).configure(conf)
+  end
+end

data/templates/new_gem/test/plugin/test_output.rb.erb

@@ -0,0 +1,18 @@
+require "helper"
+require "fluent/plugin/<%= plugin_filename %>"
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  setup do
+    Fluent::Test.setup
+  end
+
+  test "failure" do
+    flunk
+  end
+
+  private
+
+  def create_driver(conf)
+    Fluent::Test::Driver::Output.new(Fluent::Plugin::<%= class_name %>).configure(conf)
+  end
+end

data/templates/new_gem/test/plugin/test_parser.rb.erb

@@ -0,0 +1,18 @@
+require "helper"
+require "fluent/plugin/<%= plugin_filename %>"
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  setup do
+    Fluent::Test.setup
+  end
+
+  test "failure" do
+    flunk
+  end
+
+  private
+
+  def create_driver(conf)
+    Fluent::Test::Driver::Parser.new(Fluent::Plugin::<%= class_name %>).configure(conf)
+  end
+end

data/templates/plugin_config_formatter/param.md-compact.erb

@@ -0,0 +1,25 @@
+<%-
+type = config[:type]
+required_label = config[:required] ? "required" : "optional"
+default = config[:default]
+alias_name = config[:alias]
+deprecated = config[:deprecated]
+obsoleted = config[:obsoleted]
+description = config[:desc]
+-%>
+* **<%= name %>** (<%= type %>) (<%= required_label %>): <%= description %>
+<%- if type == :enum -%>
+  * Available values: <%= config[:list].join(", ") %>
+<%- end -%>
+<%- if default -%>
+  * Default value: `<%= default %>`.
+<%- end -%>
+<%- if alias_name -%>
+  * Alias: <%= alias_name %>
+<%- end -%>
+<%- if deprecated -%>
+  * Deprecated: <%= deprecated %>
+<%- end -%>
+<%- if obsoleted -%>
+  * Obsoleted: <%= :obsoleted %>
+<%- end -%>

data/templates/plugin_config_formatter/param.md.erb

@@ -0,0 +1,34 @@
+<%-
+type = config[:type]
+required_label = config[:required] ? "required" : "optional"
+default = config[:default]
+alias_name = config[:alias]
+deprecated = config[:deprecated]
+obsoleted = config[:obsoleted]
+description = config[:desc]
+param_header = "#" * (3 + level)
+-%>
+<%= param_header %> <%= name %> (<%= type %>) (<%= required_label %>)
+
+<%= description %>
+<%- if type == :enum -%>
+
+Available values: <%= config[:list].join(", ") %>
+<%- end -%>
+<%- if default -%>
+
+Default value: `<%= default %>`.
+<%- end -%>
+<%- if alias_name -%>
+
+Alias: <%= alias_name %>
+<%- end -%>
+<%- if deprecated -%>
+
+Deprecated: <%= deprecated %>
+<%- end -%>
+<%- if obsoleted -%>
+
+Obsoleted: <%= :obsoleted %>
+<%- end -%>
+

data/templates/plugin_config_formatter/section.md.erb

@@ -0,0 +1,12 @@
+<%-
+section_header = "#" * (3 + level)
+required_label = required ? "required" : "optional"
+multiple_label = multi ? "multiple" : "single"
+-%>
+<%= section_header %> \<<%= section_name %>\> section (<%= required_label %>) (<%= multiple_label %>)
+<%- if alias_name -%>
+
+Alias: <%= alias_name %>
+<%- end -%>
+
+<%= dump_section_markdown(sub_section, level + 1) %>

data/test/command/test_binlog_reader.rb

@@ -79,15 +79,6 @@ class TestBaseCommand < ::Test::Unit::TestCase
   ensure
     ENV['TZ'] = old
   end
-
-  def capture_stdout
-    out = StringIO.new
-    $stdout = out
-    yield
-    out.string.force_encoding('utf-8')
-  ensure
-    $stdout = STDOUT
-  end
 end
 
 class TestHead < TestBaseCommand

data/test/command/test_plugin_config_formatter.rb

@@ -0,0 +1,275 @@
+require_relative '../helper'
+
+require 'pathname'
+require 'fluent/command/plugin_config_formatter'
+require 'fluent/plugin/input'
+require 'fluent/plugin/output'
+require 'fluent/plugin/filter'
+require 'fluent/plugin/parser'
+require 'fluent/plugin/formatter'
+
+class TestFluentPluginConfigFormatter < Test::Unit::TestCase
+  class FakeInput < ::Fluent::Plugin::Input
+    ::Fluent::Plugin.register_input("fake", self)
+
+    desc "path to something"
+    config_param :path, :string
+  end
+
+  class FakeOutput < ::Fluent::Plugin::Output
+    ::Fluent::Plugin.register_output("fake", self)
+
+    desc "path to something"
+    config_param :path, :string
+
+    def process(tag, es)
+    end
+  end
+
+  class FakeFilter < ::Fluent::Plugin::Filter
+    ::Fluent::Plugin.register_filter("fake", self)
+
+    desc "path to something"
+    config_param :path, :string
+
+    def filter(tag, time, record)
+    end
+  end
+
+  class FakeParser < ::Fluent::Plugin::Parser
+    ::Fluent::Plugin.register_parser("fake", self)
+
+    desc "path to something"
+    config_param :path, :string
+
+    def parse(text)
+    end
+  end
+
+  class FakeFormatter < ::Fluent::Plugin::Formatter
+    ::Fluent::Plugin.register_formatter("fake", self)
+
+    desc "path to something"
+    config_param :path, :string
+
+    def format(tag, time, record)
+    end
+  end
+
+  class SimpleInput < ::Fluent::Plugin::Input
+    ::Fluent::Plugin.register_input("simple", self)
+    helpers :inject, :compat_parameters
+
+    desc "path to something"
+    config_param :path, :string
+  end
+
+  class ComplexOutput < ::Fluent::Plugin::Output
+    ::Fluent::Plugin.register_output("complex", self)
+    helpers :inject, :compat_parameters
+
+    config_section :authentication, required: true, multi: false do
+      desc "username"
+      config_param :username, :string
+      desc "password"
+      config_param :passowrd, :string, secret: true
+    end
+
+    config_section :parent do
+      config_section :child do
+        desc "names"
+        config_param :names, :array
+        desc "difficulty"
+        config_param :difficulty, :enum, list: [:easy, :normal, :hard], default: :normal
+      end
+    end
+
+    def process(tag, es)
+    end
+  end
+
+  sub_test_case "json" do
+    data(input: [FakeInput, "input"],
+         output: [FakeOutput, "output"],
+         filter: [FakeFilter, "filter"],
+         parser: [FakeParser, "parser"],
+         formatter: [FakeFormatter, "formatter"])
+    test "dumped config should be valid JSON" do |(klass, type)|
+      dumped_config = capture_stdout do
+        FluentPluginConfigFormatter.new(["--format=json", type, "fake"]).call
+      end
+      expected = {
+        path: {
+          desc: "path to something",
+          type: "string",
+          required: true
+        }
+      }
+      assert_equal(expected, JSON.parse(dumped_config, symbolize_names: true)[klass.name.to_sym])
+    end
+  end
+
+  sub_test_case "text" do
+    test "input simple" do
+      dumped_config = capture_stdout do
+        FluentPluginConfigFormatter.new(["--format=txt", "input", "simple"]).call
+      end
+      expected = <<TEXT
+helpers: inject,compat_parameters
+@log_level: string: (nil)
+path: string: (nil)
+TEXT
+      assert_equal(expected, dumped_config)
+    end
+
+    test "output complex" do
+      dumped_config = capture_stdout do
+        FluentPluginConfigFormatter.new(["--format=txt", "output", "complex"]).call
+      end
+      expected = <<TEXT
+helpers: inject,compat_parameters
+@log_level: string: (nil)
+time_as_integer: bool: (false)
+slow_flush_log_threshold: float: (20.0)
+<buffer>: optional, single
+ @type: string: ("memory")
+ timekey: time: (nil)
+ timekey_wait: time: (600)
+ timekey_use_utc: bool: (false)
+ timekey_zone: string: ("#{Time.now.strftime('%z')}")
+ flush_at_shutdown: bool: (nil)
+ flush_mode: enum: (:default)
+ flush_interval: time: (60)
+ flush_thread_count: integer: (1)
+ flush_thread_interval: float: (1.0)
+ flush_thread_burst_interval: float: (1.0)
+ delayed_commit_timeout: time: (60)
+ overflow_action: enum: (:throw_exception)
+ retry_forever: bool: (false)
+ retry_timeout: time: (259200)
+ retry_max_times: integer: (nil)
+ retry_secondary_threshold: float: (0.8)
+ retry_type: enum: (:exponential_backoff)
+ retry_wait: time: (1)
+ retry_exponential_backoff_base: float: (2)
+ retry_max_interval: time: (nil)
+ retry_randomize: bool: (true)
+ chunk_keys: : ([])
+<secondary>: optional, single
+ @type: string: (nil)
+ <buffer>: optional, single
+ <secondary>: optional, single
+<authentication>: required, single
+ username: string: (nil)
+ passowrd: string: (nil)
+<parent>: optional, multiple
+ <child>: optional, multiple
+  names: array: (nil)
+  difficulty: enum: (:normal)
+TEXT
+      assert_equal(expected, dumped_config)
+    end
+  end
+
+  sub_test_case "markdown" do
+    test "input simple" do
+      dumped_config = capture_stdout do
+        FluentPluginConfigFormatter.new(["--format=markdown", "input", "simple"]).call
+      end
+      expected = <<TEXT
+## Plugin helpers
+
+* inject
+* compat_parameters
+
+* See also: Fluent::Plugin::Input
+
+## TestFluentPluginConfigFormatter::SimpleInput
+
+### path (string) (required)
+
+path to something
+
+
+TEXT
+      assert_equal(expected, dumped_config)
+    end
+
+    test "output complex" do
+      dumped_config = capture_stdout do
+        FluentPluginConfigFormatter.new(["--format=markdown", "output", "complex"]).call
+      end
+      expected = <<TEXT
+## Plugin helpers
+
+* inject
+* compat_parameters
+
+* See also: Fluent::Plugin::Output
+
+## TestFluentPluginConfigFormatter::ComplexOutput
+
+
+### \\<authentication\\> section (required) (single)
+
+#### username (string) (required)
+
+username
+
+#### passowrd (string) (required)
+
+password
+
+
+
+### \\<parent\\> section (optional) (multiple)
+
+
+#### \\<child\\> section (optional) (multiple)
+
+##### names (array) (required)
+
+names
+
+##### difficulty (enum) (optional)
+
+difficulty
+
+Available values: easy, normal, hard
+
+Default value: `normal`.
+
+
+
+
+TEXT
+      assert_equal(expected, dumped_config)
+    end
+  end
+
+  sub_test_case "arguments" do
+    data do
+      hash = {}
+      ["input", "output", "filter", "parser", "formatter"].each do |type|
+        ["txt", "json", "markdown"].each do |format|
+          argv = ["--format=#{format}"]
+          [
+            ["--verbose", "--compact"],
+            ["--verbose"],
+            ["--compact"]
+          ].each do |options|
+            hash[(argv + options).join(" ")] = argv + options + [type, "fake"]
+          end
+        end
+      end
+      hash
+    end
+    test "dump txt" do |argv|
+      capture_stdout do
+        assert_nothing_raised do
+          FluentPluginConfigFormatter.new(argv).call
+        end
+      end
+    end
+  end
+end

data/test/command/test_plugin_generator.rb

@@ -0,0 +1,66 @@
+require_relative '../helper'
+
+require 'pathname'
+require 'fluent/command/plugin_generator'
+
+class TestFluentPluginGenerator < Test::Unit::TestCase
+  TEMP_DIR = "tmp/plugin_generator"
+  setup do
+    FileUtils.mkdir_p(TEMP_DIR)
+    @pwd = Dir.pwd
+    Dir.chdir(TEMP_DIR)
+  end
+
+  teardown do
+    Dir.chdir(@pwd)
+    FileUtils.rm_rf(TEMP_DIR)
+  end
+
+  data(input: ["input", "in"],
+       output: ["output", "out"],
+       filter: ["filter", "filter"],
+       parser: ["parser", "parser"],
+       formatter: ["formatter", "formatter"])
+  test "generate plugin" do |(type, part)|
+    capture_stdout do
+      FluentPluginGenerator.new([type, "fake"]).call
+    end
+    plugin_base_dir = Pathname("fluent-plugin-fake")
+    assert { plugin_base_dir.directory? }
+    expected = [
+      "fluent-plugin-fake",
+      "fluent-plugin-fake/Gemfile",
+      "fluent-plugin-fake/LICENSE",
+      "fluent-plugin-fake/README.md",
+      "fluent-plugin-fake/Rakefile",
+      "fluent-plugin-fake/fluent-plugin-fake.gemspec",
+      "fluent-plugin-fake/lib",
+      "fluent-plugin-fake/lib/fluent",
+      "fluent-plugin-fake/lib/fluent/plugin",
+      "fluent-plugin-fake/lib/fluent/plugin/#{part}_fake.rb",
+      "fluent-plugin-fake/test",
+      "fluent-plugin-fake/test/helper.rb",
+      "fluent-plugin-fake/test/plugin",
+      "fluent-plugin-fake/test/plugin/test_#{part}_fake.rb",
+    ]
+    actual = plugin_base_dir.find.reject {|f| f.fnmatch("*/.git*") }.map(&:to_s).sort
+    assert_equal(expected, actual)
+  end
+
+  test "no license" do
+    capture_stdout do
+      FluentPluginGenerator.new(["--no-license", "filter", "fake"]).call
+    end
+    assert { !Pathname("fluent-plugin-fake/LICENSE").exist? }
+    assert { Pathname("fluent-plugin-fake/Gemfile").exist? }
+  end
+
+  test "unknown license" do
+    out = capture_stdout do
+      assert_raise(SystemExit) do
+        FluentPluginGenerator.new(["--license=unknown", "filter", "fake"]).call
+      end
+    end
+    assert { out.lines.include?("License: unknown\n") }
+  end
+end