fluentd 1.16.7-x86-mingw32 → 1.17.0-x86-mingw32

data/test/command/test_fluentd.rb

@@ -128,14 +128,11 @@ class TestFluentdCommand < ::Test::Unit::TestCase
 
   # ATTENTION: This stops taking logs when all `pattern_list` match or timeout,
   # so `patterns_not_match` can test only logs up to that point.
-  # You can pass a block to assert something after log matching.
   def assert_log_matches(cmdline, *pattern_list, patterns_not_match: [], timeout: 20, env: {})
     matched = false
     matched_wrongly = false
-    error_msg_match = ""
+    assert_error_msg = ""
     stdio_buf = ""
-    succeeded_block = true
-    error_msg_block = ""
     begin
       execute_command(cmdline, @tmp_dir, env) do |pid, stdout|
         begin
@@ -166,13 +163,6 @@ class TestFluentdCommand < ::Test::Unit::TestCase
               end
             end
           end
-
-          begin
-            yield if block_given?
-          rescue => e
-            succeeded_block = false
-            error_msg_block = "failed block execution after matching: #{e}"
-          end
         ensure
           if SUPERVISOR_PID_PATTERN =~ stdio_buf
             @supervisor_pid = $1.to_i
@@ -183,19 +173,19 @@ class TestFluentdCommand < ::Test::Unit::TestCase
         end
       end
     rescue Timeout::Error
-      error_msg_match = "execution timeout"
+      assert_error_msg = "execution timeout"
       # https://github.com/fluent/fluentd/issues/4095
       # On Windows, timeout without `@supervisor_pid` means that the test is invalid,
       # since the supervisor process will survive without being killed correctly.
       flunk("Invalid test: The pid of supervisor could not be taken, which is necessary on Windows.") if Fluent.windows? && @supervisor_pid.nil?
     rescue => e
-      error_msg_match = "unexpected error in launching fluentd: #{e.inspect}"
+      assert_error_msg = "unexpected error in launching fluentd: #{e.inspect}"
     else
-      error_msg_match = "log doesn't match" unless matched
+      assert_error_msg = "log doesn't match" unless matched
     end
 
     if patterns_not_match.empty?
-      error_msg_match = build_message(error_msg_match,
+      assert_error_msg = build_message(assert_error_msg,
                                        "<?>\nwas expected to include:\n<?>",
                                        stdio_buf, pattern_list)
     else
@@ -207,17 +197,16 @@ class TestFluentdCommand < ::Test::Unit::TestCase
                             lines.any?{|line| line.include?(ptn) }
                           end
         if matched_wrongly
-          error_msg_match << "\n" unless error_msg_match.empty?
-          error_msg_match << "pattern exists in logs wrongly: #{ptn}"
+          assert_error_msg << "\n" unless assert_error_msg.empty?
+          assert_error_msg << "pattern exists in logs wrongly: #{ptn}"
         end
       end
-      error_msg_match = build_message(error_msg_match,
+      assert_error_msg = build_message(assert_error_msg,
                                        "<?>\nwas expected to include:\n<?>\nand not include:\n<?>",
                                        stdio_buf, pattern_list, patterns_not_match)
     end
 
-    assert matched && !matched_wrongly, error_msg_match
-    assert succeeded_block, error_msg_block if block_given?
+    assert matched && !matched_wrongly, assert_error_msg
   end
 
   def assert_fluentd_fails_to_start(cmdline, *pattern_list, timeout: 20)
@@ -1175,7 +1164,7 @@ CONF
     end
   end
 
-  sub_test_case 'shared socket options' do
+  sub_test_case 'sahred socket options' do
     test 'enable shared socket by default' do
       conf = ""
       conf_path = create_conf_file('empty.conf', conf)
@@ -1299,40 +1288,4 @@ CONF
                          "[debug]")
     end
   end
-
-  sub_test_case "plugin option" do
-    test "should be the default value when not specifying" do
-      conf_path = create_conf_file('test.conf', <<~CONF)
-        <source>
-          @type monitor_agent
-        </source>
-      CONF
-      assert File.exist?(conf_path)
-      cmdline = create_cmdline(conf_path)
-
-      assert_log_matches(cmdline, "fluentd worker is now running") do
-        response = Net::HTTP.get(URI.parse("http://localhost:24220/api/config.json"))
-        actual_conf = JSON.parse(response)
-        assert_equal Fluent::Supervisor.default_options[:plugin_dirs], actual_conf["plugin_dirs"]
-      end
-    end
-
-    data(short: "-p")
-    data(long: "--plugin")
-    test "can be added by specifying the option" do |option_name|
-      conf_path = create_conf_file('test.conf', <<~CONF)
-        <source>
-          @type monitor_agent
-        </source>
-      CONF
-      assert File.exist?(conf_path)
-      cmdline = create_cmdline(conf_path, option_name, @tmp_dir, option_name, @tmp_dir)
-
-      assert_log_matches(cmdline, "fluentd worker is now running") do
-        response = Net::HTTP.get(URI.parse("http://localhost:24220/api/config.json"))
-        actual_conf = JSON.parse(response)
-        assert_equal Fluent::Supervisor.default_options[:plugin_dirs] + [@tmp_dir, @tmp_dir], actual_conf["plugin_dirs"]
-      end
-    end
-  end
 end

data/test/helper.rb

@@ -71,31 +71,17 @@ end
 
 include Fluent::Test::Helpers
 
-def unused_port(num = 1, protocol:, bind: "0.0.0.0")
+def unused_port(num = 1, protocol: :tcp, bind: "0.0.0.0")
   case protocol
-  when :tcp, :tls
+  when :tcp
     unused_port_tcp(num)
   when :udp
     unused_port_udp(num, bind: bind)
-  when :all
-    unused_port_tcp_udp(num)
   else
     raise ArgumentError, "unknown protocol: #{protocol}"
   end
 end
 
-def unused_port_tcp_udp(num = 1)
-  raise "not support num > 1" if num > 1
-
-  # The default maximum number of file descriptors in macOS is 256.
-  # It might need to set num to a smaller value than that.
-  tcp_ports = unused_port_tcp(200)
-  port = unused_port_udp(1, port_list: tcp_ports)
-  raise "can't find unused port" unless port
-
-  port
-end
-
 def unused_port_tcp(num = 1)
   ports = []
   sockets = []
@@ -104,7 +90,7 @@ def unused_port_tcp(num = 1)
     sockets << s
     ports << s.addr[1]
   end
-  sockets.each(&:close)
+  sockets.each{|s| s.close }
   if num == 1
     return ports.first
   else
@@ -114,15 +100,12 @@ end
 
 PORT_RANGE_AVAILABLE = (1024...65535)
 
-def unused_port_udp(num = 1, port_list: [], bind: "0.0.0.0")
+def unused_port_udp(num = 1, bind: "0.0.0.0")
   family = IPAddr.new(IPSocket.getaddress(bind)).ipv4? ? ::Socket::AF_INET : ::Socket::AF_INET6
   ports = []
   sockets = []
-
-  use_random_port = port_list.empty?
-  i = 0
-  loop do
-    port = use_random_port ? rand(PORT_RANGE_AVAILABLE) : port_list[i]
+  while ports.size < num
+    port = rand(PORT_RANGE_AVAILABLE)
     u = UDPSocket.new(family)
     if (u.bind(bind, port) rescue nil)
       ports << port
@@ -130,11 +113,8 @@ def unused_port_udp(num = 1, port_list: [], bind: "0.0.0.0")
     else
       u.close
     end
-    i += 1
-    break if ports.size >= num
-    break if !use_random_port && i >= port_list.size
   end
-  sockets.each(&:close)
+  sockets.each{|s| s.close }
   if num == 1
     return ports.first
   else

data/test/log/test_console_adapter.rb

@@ -72,11 +72,18 @@ class ConsoleAdapterTest < Test::Unit::TestCase
        fatal: :fatal)
   def test_options(level)
     @console_logger.send(level, "subject", kwarg1: "opt1", kwarg2: "opt2")
+    lines = @logdev.logs[0].split("\n")
+    args = JSON.load(lines[1..].collect { |str| str.sub(/\s+\|/, "") }.join("\n"));
     assert_equal([
-                   "#{@timestamp_str} [#{level}]:   0.0s: subject\n" +
-                   "      | {\"kwarg1\":\"opt1\",\"kwarg2\":\"opt2\"}\n"
+                   1,
+                   "#{@timestamp_str} [#{level}]:   0.0s: subject",
+                   { "kwarg1" => "opt1", "kwarg2" => "opt2" }
                  ],
-                 @logdev.logs)
+                 [
+                   @logdev.logs.size,
+                   lines[0],
+                   args
+                 ])
   end
 
   data(debug: :debug,

data/test/plugin/in_tail/test_io_handler.rb

@@ -5,19 +5,20 @@ require 'fluent/plugin/metrics_local'
 require 'tempfile'
 
 class IntailIOHandlerTest < Test::Unit::TestCase
-  def setup
-    Tempfile.create('intail_io_handler') do |file|
-      file.binmode
-      @file = file
-      opened_file_metrics = Fluent::Plugin::LocalMetrics.new
-      opened_file_metrics.configure(config_element('metrics', '', {}))
-      closed_file_metrics = Fluent::Plugin::LocalMetrics.new
-      closed_file_metrics.configure(config_element('metrics', '', {}))
-      rotated_file_metrics = Fluent::Plugin::LocalMetrics.new
-      rotated_file_metrics.configure(config_element('metrics', '', {}))
-      @metrics = Fluent::Plugin::TailInput::MetricsInfo.new(opened_file_metrics, closed_file_metrics, rotated_file_metrics)
-      yield
-    end
+  setup do
+    @file = Tempfile.new('intail_io_handler').binmode
+    opened_file_metrics = Fluent::Plugin::LocalMetrics.new
+    opened_file_metrics.configure(config_element('metrics', '', {}))
+    closed_file_metrics = Fluent::Plugin::LocalMetrics.new
+    closed_file_metrics.configure(config_element('metrics', '', {}))
+    rotated_file_metrics = Fluent::Plugin::LocalMetrics.new
+    rotated_file_metrics.configure(config_element('metrics', '', {}))
+    @metrics = Fluent::Plugin::TailInput::MetricsInfo.new(opened_file_metrics, closed_file_metrics, rotated_file_metrics)
+  end
+
+  teardown do
+    @file.close rescue nil
+    @file.unlink rescue nil
   end
 
   def create_target_info

data/test/plugin/in_tail/test_position_file.rb

@@ -6,12 +6,13 @@ require 'fileutils'
 require 'tempfile'
 
 class IntailPositionFileTest < Test::Unit::TestCase
-  def setup
-    Tempfile.create('intail_position_file_test') do |file|
-      file.binmode
-      @file = file
-      yield
-    end
+  setup do
+    @file = Tempfile.new('intail_position_file_test').binmode
+  end
+
+  teardown do
+    @file.close rescue nil
+    @file.unlink rescue nil
   end
 
   UNWATCHED_STR = '%016x' % Fluent::Plugin::TailInput::PositionFile::UNWATCHED_POSITION

data/test/plugin/out_forward/test_ack_handler.rb

@@ -111,11 +111,11 @@ class AckHandlerTest < Test::Unit::TestCase
     r, w = IO.pipe
     begin
       w.write(chunk_id)
-      def r.recv(arg)
+      stub(r).recv { |_|
         sleep(1) # To ensure that multiple threads select the socket before closing.
-        raise IOError, 'stream closed in another thread' if self.closed?
+        raise IOError, 'stream closed in another thread' if r.closed?
         MessagePack.pack({ 'ack' => Base64.encode64('chunk_id 111') })
-      end
+      }
       ack.enqueue(r)
 
       threads = []

data/test/plugin/out_forward/test_socket_cache.rb

@@ -17,7 +17,7 @@ class SocketCacheTest < Test::Unit::TestCase
       assert_equal(socket, c.checkout_or('key') { socket })
       c.checkin(socket)
 
-      sock = mock!.open.never.subject
+      sock = dont_allow(mock!).open
       assert_equal(socket, c.checkout_or('key') { sock.open })
     end
 
@@ -130,7 +130,7 @@ class SocketCacheTest < Test::Unit::TestCase
 
       c = Fluent::Plugin::ForwardOutput::SocketCache.new(10, $log)
       sock = mock!.close { 'closed' }.subject
-      sock2 = mock!.close.never.subject
+      sock2 = dont_allow(mock!).close
       stub(sock).inspect
       stub(sock2).inspect
 
@@ -154,7 +154,7 @@ class SocketCacheTest < Test::Unit::TestCase
       Timecop.freeze(Time.parse('2016-04-13 14:00:00 +0900'))
 
       c = Fluent::Plugin::ForwardOutput::SocketCache.new(10, $log)
-      sock = mock!.close.never.subject
+      sock = dont_allow(mock!).close
       stub(sock).inspect
       c.checkout_or('key') { sock }
 

data/test/plugin/test_in_forward.rb

@@ -18,8 +18,7 @@ class ForwardInputTest < Test::Unit::TestCase
     Fluent::Test.setup
     @responses = []  # for testing responses after sending data
     @d = nil
-    # forward plugin uses TCP and UDP sockets on the same port number
-    @port = unused_port(protocol: :all)
+    @port = unused_port
   end
 
   def teardown

data/test/plugin/test_in_http.rb

@@ -18,7 +18,7 @@ class HttpInputTest < Test::Unit::TestCase
 
   def setup
     Fluent::Test.setup
-    @port = unused_port(protocol: :tcp)
+    @port = unused_port
   end
 
   def teardown
@@ -517,6 +517,28 @@ class HttpInputTest < Test::Unit::TestCase
     assert_equal_event_time time, d.events[1][1]
   end
 
+  def test_csp_report
+    d = create_driver
+    time = event_time("2011-01-02 13:14:15 UTC")
+    time_i = time.to_i
+    events = [
+      ["tag1", time, {"a"=>1}],
+      ["tag2", time, {"a"=>2}],
+    ]
+    res_codes = []
+
+    d.run(expect_records: 2) do
+      events.each do |tag, t, record|
+        res = post("/#{tag}?time=#{time_i.to_s}", record.to_json, {"Content-Type"=>"application/csp-report; charset=utf-8"})
+        res_codes << res.code
+      end
+    end
+    assert_equal ["200", "200"], res_codes
+    assert_equal events, d.events
+    assert_equal_event_time time, d.events[0][1]
+    assert_equal_event_time time, d.events[1][1]
+  end
+
   def test_application_msgpack
     d = create_driver
     time = event_time("2011-01-02 13:14:15 UTC")
@@ -982,7 +1004,7 @@ class HttpInputTest < Test::Unit::TestCase
     assert_equal ["403", "403"], res_codes
   end
 
-  def test_add_query_params 
+  def test_add_query_params
     d = create_driver(config + "add_query_params true")
     assert_equal true, d.instance.add_query_params
 

data/test/plugin/test_in_monitor_agent.rb

@@ -392,7 +392,7 @@ EOC
     end
 
     test "emit" do
-      port = unused_port(protocol: :tcp)
+      port = unused_port
       d = create_driver("
   @type monitor_agent
   bind '127.0.0.1'
@@ -451,7 +451,7 @@ EOC
 
   sub_test_case "servlets" do
     setup do
-      @port = unused_port(protocol: :tcp)
+      @port = unused_port
       # check @type and type in one configuration
       conf = <<-EOC
 <source>
@@ -759,7 +759,7 @@ plugin_id:test_filter\tplugin_category:filter\ttype:test_filter\toutput_plugin:f
     end
 
     setup do
-      @port = unused_port(protocol: :tcp)
+      @port = unused_port
       # check @type and type in one configuration
       conf = <<-EOC
 <source>
@@ -840,7 +840,7 @@ plugin_id:test_filter\tplugin_category:filter\ttype:test_filter\toutput_plugin:f
 
   sub_test_case "check the port number of http server" do
     test "on single worker environment" do
-      port = unused_port(protocol: :tcp)
+      port = unused_port
       d = create_driver("
   @type monitor_agent
   bind '127.0.0.1'
@@ -851,7 +851,7 @@ plugin_id:test_filter\tplugin_category:filter\ttype:test_filter\toutput_plugin:f
     end
 
     test "worker_id = 2 on multi worker environment" do
-      port = unused_port(protocol: :tcp)
+      port = unused_port
       Fluent::SystemConfig.overwrite_system_config('workers' => 4) do
         d = Fluent::Test::Driver::Input.new(Fluent::Plugin::MonitorAgentInput)
         d.instance.instance_eval{ @_fluentd_worker_id = 2 }
@@ -905,7 +905,7 @@ EOC
     end
 
     test "plugins have a variable named buffer does not throws NoMethodError" do
-      port = unused_port(protocol: :tcp)
+      port = unused_port
       d = create_driver("
   @type monitor_agent
   bind '127.0.0.1'

data/test/plugin/test_in_syslog.rb

@@ -5,24 +5,24 @@ require 'fluent/plugin/in_syslog'
 class SyslogInputTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
-    @port = unused_port(protocol: :udp)
+    @port = unused_port
   end
 
   def teardown
     @port = nil
   end
 
-  def ipv4_config(port = @port)
+  def ipv4_config
     %[
-      port #{port}
+      port #{@port}
       bind 127.0.0.1
       tag syslog
     ]
   end
 
-  def ipv6_config(port = @port)
+  def ipv6_config
     %[
-      port #{port}
+      port #{@port}
       bind ::1
       tag syslog
     ]
@@ -69,8 +69,7 @@ EOS
        'Use transport and protocol' => ["protocol_type udp\n<transport tcp>\n </transport>", :udp, :tcp])
   def test_configure_protocol(param)
     conf, proto_type, transport_proto_type = *param
-    port = unused_port(protocol: proto_type ? proto_type : transport_proto_type)
-    d = create_driver([ipv4_config(port), conf].join("\n"))
+    d = create_driver([ipv4_config, conf].join("\n"))
 
     assert_equal(d.instance.protocol_type, proto_type)
     assert_equal(d.instance.transport_config.protocol, transport_proto_type)
@@ -159,13 +158,12 @@ EOS
   end
 
   def test_msg_size_with_tcp
-    port = unused_port(protocol: :tcp)
-    d = create_driver([ipv4_config(port), "<transport tcp> \n</transport>"].join("\n"))
+    d = create_driver([ipv4_config, "<transport tcp> \n</transport>"].join("\n"))
     tests = create_test_case
 
     d.run(expect_emits: 2) do
       tests.each {|test|
-        TCPSocket.open('127.0.0.1', port) do |s|
+        TCPSocket.open('127.0.0.1', @port) do |s|
           s.send(test['msg'], 0)
         end
       }
@@ -191,12 +189,11 @@ EOS
   end
 
   def test_msg_size_with_same_tcp_connection
-    port = unused_port(protocol: :tcp)
-    d = create_driver([ipv4_config(port), "<transport tcp> \n</transport>"].join("\n"))
+    d = create_driver([ipv4_config, "<transport tcp> \n</transport>"].join("\n"))
     tests = create_test_case
 
     d.run(expect_emits: 2) do
-      TCPSocket.open('127.0.0.1', port) do |s|
+      TCPSocket.open('127.0.0.1', @port) do |s|
         tests.each {|test|
           s.send(test['msg'], 0)
         }
@@ -350,13 +347,12 @@ EOS
 
   sub_test_case 'octet counting frame' do
     def test_msg_size_with_tcp
-      port = unused_port(protocol: :tcp)
-      d = create_driver([ipv4_config(port), "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
+      d = create_driver([ipv4_config, "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
       tests = create_test_case
 
       d.run(expect_emits: 2) do
         tests.each {|test|
-          TCPSocket.open('127.0.0.1', port) do |s|
+          TCPSocket.open('127.0.0.1', @port) do |s|
             s.send(test['msg'], 0)
           end
         }
@@ -367,12 +363,11 @@ EOS
     end
 
     def test_msg_size_with_same_tcp_connection
-      port = unused_port(protocol: :tcp)
-      d = create_driver([ipv4_config(port), "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
+      d = create_driver([ipv4_config, "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
       tests = create_test_case
 
       d.run(expect_emits: 2) do
-        TCPSocket.open('127.0.0.1', port) do |s|
+        TCPSocket.open('127.0.0.1', @port) do |s|
           tests.each {|test|
             s.send(test['msg'], 0)
           }
@@ -474,8 +469,7 @@ EOS
   end
 
   def test_send_keepalive_packet_is_disabled_by_default
-    port = unused_port(protocol: :tcp)
-    d = create_driver(ipv4_config(port) + %[
+    d = create_driver(ipv4_config + %[
       <transport tcp>
       </transport>
       protocol tcp
@@ -485,20 +479,19 @@ EOS
 
   def test_send_keepalive_packet_can_be_enabled
     addr = "127.0.0.1"
-    port = unused_port(protocol: :tcp)
-    d = create_driver(ipv4_config(port) + %[
+    d = create_driver(ipv4_config + %[
       <transport tcp>
       </transport>
       send_keepalive_packet true
     ])
     assert_true d.instance.send_keepalive_packet
     mock.proxy(d.instance).server_create_connection(
-      :in_syslog_tcp_server, port,
+      :in_syslog_tcp_server, @port,
       bind: addr,
       resolve_name: nil,
       send_keepalive_packet: true)
     d.run do
-      TCPSocket.open(addr, port)
+      TCPSocket.open(addr, @port)
     end
   end