fluentd 1.16.5-x64-mingw32 → 1.17.1-x64-mingw32

data/test/command/test_ca_generate.rb

@@ -1,70 +0,0 @@
-require_relative '../helper'
-
-require 'yajl'
-require 'flexmock/test_unit'
-require 'tmpdir'
-
-require 'fluent/command/ca_generate'
-require 'fluent/event'
-
-class TestFluentCaGenerate < ::Test::Unit::TestCase
-  def test_generate_ca_pair
-    cert, key = Fluent::CaGenerate.generate_ca_pair(Fluent::CaGenerate::DEFAULT_OPTIONS)
-    assert_equal(OpenSSL::X509::Certificate, cert.class)
-    assert_true(key.private?)
-  end
-
-  def test_ca_generate
-    dumped_output = capture_stdout do
-      Dir.mktmpdir do |dir|
-        Fluent::CaGenerate.new([dir, "fluentd"]).call
-        assert_true(File.exist?(File.join(dir, "ca_key.pem")))
-        assert_true(File.exist?(File.join(dir, "ca_cert.pem")))
-      end
-    end
-    expected = <<TEXT
-successfully generated: ca_key.pem, ca_cert.pem
-copy and use ca_cert.pem to client(out_forward)
-TEXT
-    assert_equal(expected, dumped_output)
-  end
-
-  sub_test_case "configure options" do
-    test "should respond multiple options" do
-      dumped_output = capture_stdout do
-        Dir.mktmpdir do |dir|
-          Fluent::CaGenerate.new([dir, "fluentd",
-                                  "--country", "JP", "--key-length", "4096",
-                                  "--state", "Tokyo", "--locality", "Chiyoda-ku",
-                                  "--common-name", "Forward CA"]).call
-          assert_true(File.exist?(File.join(dir, "ca_key.pem")))
-          assert_true(File.exist?(File.join(dir, "ca_cert.pem")))
-        end
-      end
-      expected = <<TEXT
-successfully generated: ca_key.pem, ca_cert.pem
-copy and use ca_cert.pem to client(out_forward)
-TEXT
-      assert_equal(expected, dumped_output)
-    end
-
-    test "invalid options" do
-      Dir.mktmpdir do |dir|
-        assert_raise(OptionParser::InvalidOption) do
-          Fluent::CaGenerate.new([dir, "fluentd",
-                                  "--invalid"]).call
-        end
-        assert_false(File.exist?(File.join(dir, "ca_key.pem")))
-        assert_false(File.exist?(File.join(dir, "ca_cert.pem")))
-      end
-    end
-
-    test "empty options" do
-      assert_raise(SystemExit) do
-        capture_stdout do
-          Fluent::CaGenerate.new([]).call
-        end
-      end
-    end
-  end
-end

data/test/command/test_cap_ctl.rb

@@ -1,100 +0,0 @@
-require_relative '../helper'
-
-require 'tempfile'
-require 'fluent/command/cap_ctl'
-
-class TestFluentCapCtl < Test::Unit::TestCase
-  setup do
-    omit "This environment does not handle Linux capability" unless defined?(CapNG)
-  end
-
-  sub_test_case "success" do
-    test "clear capability" do
-      logs = capture_stdout do
-        Fluent::CapCtl.new(["--clear"]).call
-      end
-      expression = /\AClear capabilities .*\n/m
-      assert_match expression, logs
-    end
-
-    test "add capability" do
-      logs = capture_stdout do
-        Fluent::CapCtl.new(["--add", "dac_override"]).call
-      end
-      expression = /\AUpdating .* done.\nAdding .*\n/m
-      assert_match expression, logs
-    end
-
-    test "drop capability" do
-      logs = capture_stdout do
-        Fluent::CapCtl.new(["--drop", "chown"]).call
-      end
-      expression = /\AUpdating .* done.\nDropping .*\n/m
-      assert_match expression, logs
-    end
-
-    test "get capability" do
-      logs = capture_stdout do
-        Fluent::CapCtl.new(["--get"]).call
-      end
-      expression = /\ACapabilities in .*,\nEffective:   .*\nInheritable: .*\nPermitted:   .*/m
-      assert_match expression, logs
-    end
-  end
-
-  sub_test_case "success with file" do
-    test "clear capability" do
-      logs = capture_stdout do
-        Tempfile.create("fluent-cap-") do |tempfile|
-          Fluent::CapCtl.new(["--clear-cap", "-f", tempfile.path]).call
-        end
-      end
-      expression = /\AClear capabilities .*\n/m
-      assert_match expression, logs
-    end
-
-    test "add capability" do
-      logs = capture_stdout do
-        Tempfile.create("fluent-cap-") do |tempfile|
-          Fluent::CapCtl.new(["--add", "dac_override", "-f", tempfile.path]).call
-        end
-      end
-      expression = /\AUpdating .* done.\nAdding .*\n/m
-      assert_match expression, logs
-    end
-
-    test "drop capability" do
-      logs = capture_stdout do
-        Tempfile.create("fluent-cap-") do |tempfile|
-          Fluent::CapCtl.new(["--drop", "chown", "-f", tempfile.path]).call
-        end
-      end
-      expression = /\AUpdating .* done.\nDropping .*\n/m
-      assert_match expression, logs
-    end
-
-    test "get capability" do
-      logs = capture_stdout do
-        Tempfile.create("fluent-cap-") do |tempfile|
-          Fluent::CapCtl.new(["--get", "-f", tempfile.path]).call
-        end
-      end
-      expression = /\ACapabilities in .*,\nEffective:   .*\nInheritable: .*\nPermitted:   .*/m
-      assert_match expression, logs
-    end
-  end
-
-  sub_test_case "invalid" do
-    test "add capability" do
-      assert_raise(ArgumentError) do
-        Fluent::CapCtl.new(["--add", "nonexitent"]).call
-      end
-    end
-
-    test "drop capability" do
-      assert_raise(ArgumentError) do
-        Fluent::CapCtl.new(["--drop", "invalid"]).call
-      end
-    end
-  end
-end

data/test/command/test_cat.rb

@@ -1,128 +0,0 @@
-require_relative '../helper'
-
-require 'test-unit'
-require 'open3'
-require 'fluent/plugin/output'
-require 'fluent/plugin/in_forward'
-require 'fluent/plugin/out_secondary_file'
-require 'fluent/test/driver/output'
-require 'fluent/test/driver/input'
-
-class TestFluentCat < ::Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-    FileUtils.mkdir_p(TMP_DIR)
-    @record = { 'key' => 'value' }
-    @time = event_time
-    @es = Fluent::OneEventStream.new(@time, @record)
-    @primary = create_primary
-    metadata = @primary.buffer.new_metadata
-    @chunk = create_chunk(@primary, metadata, @es)
-    @port = unused_port
-  end
-
-  def teardown
-    FileUtils.rm_rf(TMP_DIR)
-    @port = nil
-  end
-
-  TMP_DIR = File.expand_path(File.dirname(__FILE__) + "/../tmp/command/fluent_cat#{ENV['TEST_ENV_NUMBER']}")
-  FLUENT_CAT_COMMAND = File.expand_path(File.dirname(__FILE__) + "/../../bin/fluent-cat")
-
-  def config
-    %[
-      port #{@port}
-      bind 127.0.0.1
-    ]
-  end
-
-  SECONDARY_CONFIG = %[
-    directory #{TMP_DIR}
-  ]
-
-  class DummyOutput < Fluent::Plugin::Output
-    def write(chunk); end
-  end
-
-  def create_driver(conf=config)
-    Fluent::Test::Driver::Input.new(Fluent::Plugin::ForwardInput).configure(conf)
-  end
-
-  def create_primary(buffer_cofig = config_element('buffer'))
-    DummyOutput.new.configure(config_element('ROOT','',{}, [buffer_cofig]))
-  end
-
-  def create_secondary_driver(conf=SECONDARY_CONFIG)
-    c = Fluent::Test::Driver::Output.new(Fluent::Plugin::SecondaryFileOutput)
-    c.instance.acts_as_secondary(@primary)
-    c.configure(conf)
-  end
-
-  def create_chunk(primary, metadata, es)
-    primary.buffer.generate_chunk(metadata).tap do |c|
-      c.concat(es.to_msgpack_stream, es.size)
-      c.commit
-    end
-  end
-
-  sub_test_case "json" do
-    def test_cat_json
-      d = create_driver
-      d.run(expect_records: 1) do
-        Open3.pipeline_w("#{ServerEngine.ruby_bin_path} #{FLUENT_CAT_COMMAND} --port #{@port} json") do |stdin|
-          stdin.puts('{"key":"value"}')
-          stdin.close
-        end
-      end
-      event = d.events.first
-      assert_equal([1, "json", @record],
-                   [d.events.size, event.first, event.last])
-    end
-  end
-
-  sub_test_case "msgpack" do
-    def test_cat_secondary_file
-      d = create_secondary_driver
-      path = d.instance.write(@chunk)
-      d = create_driver
-      d.run(expect_records: 1) do
-        Open3.pipeline_w("#{ServerEngine.ruby_bin_path} #{FLUENT_CAT_COMMAND} --port #{@port} --format msgpack secondary") do |stdin|
-          stdin.write(File.read(path))
-          stdin.close
-        end
-      end
-      event = d.events.first
-      assert_equal([1, "secondary", @record],
-                   [d.events.size, event.first, event.last])
-    end
-  end
-
-  sub_test_case "send specific event time" do
-    def test_without_event_time
-      event_time = Fluent::EventTime.now
-      d = create_driver
-      d.run(expect_records: 1) do
-        Open3.pipeline_w("#{ServerEngine.ruby_bin_path} #{FLUENT_CAT_COMMAND} --port #{@port} tag") do |stdin|
-          stdin.puts('{"key":"value"}')
-          stdin.close
-        end
-      end
-      event = d.events.first
-      assert_in_delta(event_time.to_f, event[1].to_f, 3.0) # expect command to be finished in 3 seconds
-      assert_equal([1, "tag", true, @record],
-                   [d.events.size, event.first, event_time.to_f < event[1].to_f, event.last])
-    end
-
-    def test_with_event_time
-      event_time = "2021-01-02 13:14:15.0+00:00"
-      d = create_driver
-      d.run(expect_records: 1) do
-        Open3.pipeline_w("#{ServerEngine.ruby_bin_path} #{FLUENT_CAT_COMMAND} --port #{@port} --event-time '#{event_time}' tag") do |stdin|
-          stdin.puts('{"key":"value"}')
-          stdin.close
-        end
-      end
-      assert_equal([["tag", Fluent::EventTime.parse(event_time), @record]], d.events)
-    end
-  end
-end

data/test/command/test_ctl.rb

@@ -1,56 +0,0 @@
-require_relative '../helper'
-
-require 'test-unit'
-require 'win32/event' if Fluent.windows?
-
-require 'fluent/command/ctl'
-
-class TestFluentdCtl < ::Test::Unit::TestCase
-  def assert_win32_event(event_name, command, pid_or_svcname)
-    event = Win32::Event.new(event_name)
-    ipc = Win32::Ipc.new(event.handle)
-    ret = Win32::Ipc::TIMEOUT
-
-    wait_thread = Thread.new do
-      ret = ipc.wait(1)
-    end
-    Fluent::Ctl.new([command, pid_or_svcname]).call
-    wait_thread.join
-    assert_equal(Win32::Ipc::SIGNALED, ret)
-  end
-
-  data("shutdown" => ["shutdown", "TERM", ""],
-       "restart" => ["restart", "HUP", "HUP"],
-       "flush" => ["flush", "USR1", "USR1"],
-       "reload" => ["reload", "USR2", "USR2"])
-  def test_commands(data)
-    command, signal, event_suffix = data
-
-    if Fluent.windows?
-      event_name = "fluentd_54321"
-      event_name << "_#{event_suffix}" unless event_suffix.empty?
-      assert_win32_event(event_name, command, "54321")
-    else
-      got_signal = false
-      Signal.trap(signal) do
-        got_signal = true
-      end
-      Fluent::Ctl.new([command, Process.pid.to_s]).call
-      assert_true(got_signal)
-    end
-  end
-
-  data("shutdown" => ["shutdown", ""],
-       "restart" => ["restart", "HUP"],
-       "flush" => ["flush", "USR1"],
-       "reload" => ["reload", "USR2"])
-  def test_commands_with_winsvcname(data)
-    omit "Only for Windows" unless Fluent.windows?
-
-    command, event_suffix = data
-    event_name = "testfluentdwinsvc"
-    event_name << "_#{event_suffix}" unless event_suffix.empty?
-
-    assert_win32_event(event_name, command, "testfluentdwinsvc")
-  end
-end