From 8d1a490358bcbe97b58e837fa02ed8f50d656399 Mon Sep 17 00:00:00 2001
From: Daijiro Fukuda <fukuda@clear-code.com>
Date: Tue, 26 Nov 2024 14:22:23 +0900
Subject: [PATCH 1/5] ci: filter_parser: reorganize parser error tests

Signed-off-by: Daijiro Fukuda <fukuda@clear-code.com>
---
 test/plugin/test_filter_parser.rb | 115 ++++++++++++++++++------------
 1 file changed, 71 insertions(+), 44 deletions(-)

diff --git a/test/plugin/test_filter_parser.rb b/test/plugin/test_filter_parser.rb
index 45df597400..0532ae0ab5 100644
--- a/test/plugin/test_filter_parser.rb
+++ b/test/plugin/test_filter_parser.rb
@@ -538,30 +538,6 @@ def test_time_should_be_reserved(conf)
     assert_equal t, filtered[2][0]
   end
 
-  CONFIG_INVALID_TIME_VALUE = %[
-    key_name data
-    <parse>
-      @type json
-    </parse>
-  ] # 'time' is implicit @time_key
-  def test_filter_invalid_time_data
-    # should not raise errors
-    time = Time.now.to_i
-    d = create_driver(CONFIG_INVALID_TIME_VALUE)
-    assert_nothing_raised {
-      d.run(default_tag: @tag) do
-        d.feed(time, {'data' => '{"time":[], "f1":"v1"}'})
-        d.feed(time, {'data' => '{"time":"thisisnottime", "f1":"v1"}'})
-      end
-    }
-    filtered = d.filtered
-    assert_equal 1, filtered.length
-
-    assert_equal 0, filtered[0][0].to_i
-    assert_equal 'v1', filtered[0][1]['f1']
-    assert_equal nil, filtered[0][1]['time']
-  end
-
   # REGEXP = /^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>[^\"]*)")?$/
 
   CONFIG_NOT_REPLACE = %[
@@ -656,15 +632,6 @@ def test_filter_key_not_exist
   INVALID_MESSAGE = 'foo bar'
   VALID_MESSAGE   = 'col1=foo col2=bar'
 
-  def test_call_emit_error_event_when_parser_error
-    d = create_driver(CONFIG_INVALID_TIME_VALUE)
-    flexmock(d.instance.router).should_receive(:emit_error_event).
-      with(String, Integer, Hash, ParserError).once
-    d.run do
-      d.feed(@tag, Fluent::EventTime.now.to_i, {'data' => '{"time":[], "f1":"v1"}'})
-    end
-  end
-
   CONFIG_UNMATCHED_PATTERN_LOG = %[
     key_name message
     <parse>
@@ -706,17 +673,6 @@ def test_pattern_is_mismached_with_emit_invalid_record_to_error
       assert_equal 0, d.filtered.length
     end
 
-    def test_parser_error_with_emit_invalid_record_to_error
-      d = create_driver(CONFIG_INVALID_TIME_VALUE + "emit_invalid_record_to_error false")
-      flexmock(d.instance.router).should_receive(:emit_error_event).never
-      assert_nothing_raised {
-        d.run do
-          d.feed(@tag, Fluent::EventTime.now.to_i, {'data' => '{"time":[], "f1":"v1"}'})
-        end
-      }
-      assert_equal 0, d.filtered.length
-    end
-
     def test_key_not_exist_with_emit_invalid_record_to_error
       d = create_driver(CONFIG_NOT_IGNORE + "emit_invalid_record_to_error false")
       flexmock(d.instance.router).should_receive(:emit_error_event).never
@@ -728,4 +684,75 @@ def test_key_not_exist_with_emit_invalid_record_to_error
       assert_equal 0, d.filtered.length
     end
   end
+
+  sub_test_case "abnormal cases" do
+    module HashExcept
+      refine Hash do
+        def except(*keys)
+          reject do |key, _|
+            keys.include?(key)
+          end
+        end
+      end
+    end
+
+    # Ruby 2.x does not support Hash#except.
+    using HashExcept unless {}.respond_to?(:except)
+
+    def run_and_assert(driver, records:, expected_records:, expected_error_records:, expected_errors:)
+      driver.run do
+        records.each do |record|
+          driver.feed(@tag, Fluent::EventTime.now.to_i, record)
+        end
+      end
+
+      assert_equal(
+        [
+          expected_records,
+          expected_error_records,
+          expected_errors.collect { |e| [e.class, e.message] },
+        ],
+        [
+          driver.filtered_records,
+          driver.error_events.collect { |_, _, record, _| record },
+          driver.error_events.collect { |_, _, _, e| [e.class, e.message] },
+        ]
+      )
+    end
+
+    data(
+      "invalid format with default" => {
+        records: [{'data' => '{"time":[], "f1":"v1"}'}],
+        additional_config: "",
+        expected_records: [],
+        expected_error_records: [{'data' => '{"time":[], "f1":"v1"}'}],
+        expected_errors: [Fluent::Plugin::Parser::ParserError.new("value must be a string or a number: [](Array)")],
+      },
+      "invalid format with disabled emit_invalid_record_to_error" => {
+        records: [{'data' => '{"time":[], "f1":"v1"}'}],
+        additional_config: "emit_invalid_record_to_error false",
+        expected_records: [],
+        expected_error_records: [],
+        expected_errors: [],
+      },
+      "mixed valid and invalid with default" => {
+        records: [{'data' => '{"time":[], "f1":"v1"}'}, {'data' => '{"time":0, "f1":"v1"}'}],
+        additional_config: "",
+        expected_records: [{"f1" => "v1"}],
+        expected_error_records: [{'data' => '{"time":[], "f1":"v1"}'}],
+        expected_errors: [Fluent::Plugin::Parser::ParserError.new("value must be a string or a number: [](Array)")],
+      },
+    )
+    def test_parser_error(data)
+      driver = create_driver(<<~EOC)
+        key_name data
+        #{data[:additional_config]}
+        <parse>
+          @type json
+        </parse>
+      EOC
+
+      run_and_assert(driver, **data.except(:additional_config))
+    end
+  end
 end

From 4d9f57cbb1405efeeca65ea3c60487224abaf88e Mon Sep 17 00:00:00 2001
From: Daijiro Fukuda <fukuda@clear-code.com>
Date: Tue, 26 Nov 2024 14:28:35 +0900
Subject: [PATCH 2/5] ci: filter_parser: reorganize invalid bytes tests

Signed-off-by: Daijiro Fukuda <fukuda@clear-code.com>
---
 test/plugin/test_filter_parser.rb | 141 ++++++++++++++++++------------
 1 file changed, 83 insertions(+), 58 deletions(-)

diff --git a/test/plugin/test_filter_parser.rb b/test/plugin/test_filter_parser.rb
index 0532ae0ab5..c6ef507d80 100644
--- a/test/plugin/test_filter_parser.rb
+++ b/test/plugin/test_filter_parser.rb
@@ -538,64 +538,6 @@ def test_time_should_be_reserved(conf)
     assert_equal t, filtered[2][0]
   end
 
-  # REGEXP = /^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>[^\"]*)")?$/
-
-  CONFIG_NOT_REPLACE = %[
-    key_name data
-    <parse>
-      @type regexp
-      expression /^(?<message>.*)$/
-    </parse>
-  ]
-  CONFIG_INVALID_BYTE = CONFIG_NOT_REPLACE + %[
-    replace_invalid_sequence true
-  ]
-  def test_filter_invalid_byte
-    invalid_utf8 = "\xff".force_encoding('UTF-8')
-
-    d = create_driver(CONFIG_NOT_REPLACE)
-    d.run do
-      d.feed(@tag, Fluent::EventTime.now.to_i, {'data' => invalid_utf8})
-    end
-    error_event = d.error_events.first
-    assert_equal "test", error_event[0]
-    assert_instance_of ArgumentError, error_event[3]
-
-    d = create_driver(CONFIG_INVALID_BYTE)
-    assert_nothing_raised {
-      d.run do
-        d.feed(@tag, Fluent::EventTime.now.to_i, {'data' => invalid_utf8})
-      end
-    }
-    filtered = d.filtered
-    assert_equal 1, filtered.length
-    assert_nil filtered[0][1]['data']
-    assert_equal '?'.force_encoding('UTF-8'), filtered[0][1]['message']
-
-    d = create_driver(CONFIG_INVALID_BYTE + %[reserve_data yes])
-    assert_nothing_raised {
-      d.run do
-        d.feed(@tag, Fluent::EventTime.now.to_i, {'data' => invalid_utf8})
-      end
-    }
-    filtered = d.filtered
-    assert_equal 1, filtered.length
-    assert_equal invalid_utf8, filtered[0][1]['data']
-    assert_equal '?'.force_encoding('UTF-8'), filtered[0][1]['message']
-
-    invalid_ascii = "\xff".force_encoding('US-ASCII')
-    d = create_driver(CONFIG_INVALID_BYTE)
-    assert_nothing_raised {
-      d.run do
-        d.feed(@tag, Fluent::EventTime.now.to_i, {'data' => invalid_ascii})
-      end
-    }
-    filtered = d.filtered
-    assert_equal 1, filtered.length
-    assert_nil filtered[0][1]['data']
-    assert_equal '?'.force_encoding('US-ASCII'), filtered[0][1]['message']
-  end
-
   CONFIG_NOT_IGNORE = %[
     key_name data
     hash_value_field parsed
@@ -754,5 +696,88 @@ def test_parser_error(data)
 
       run_and_assert(driver, **data.except(:additional_config))
     end
+
+    data(
+      "UTF-8 with default" => {
+        records: [{"data" => "\xff"}],
+        additional_config: "",
+        expected_records: [],
+        expected_error_records: [{"data" => "\xff"}],
+        expected_errors: [ArgumentError.new("invalid byte sequence in UTF-8")],
+      },
+      "UTF-8 with replace_invalid_sequence" => {
+        records: [{"data" => "\xff"}],
+        additional_config: "replace_invalid_sequence",
+        expected_records: [{"message" => "?"}],
+        expected_error_records: [],
+        expected_errors: [],
+      },
+      "UTF-8 with replace_invalid_sequence and reserve_data" => {
+        records: [{"data" => "\xff"}],
+        additional_config: ["replace_invalid_sequence", "reserve_data"].join("\n"),
+        expected_records: [{"message" => "?", "data" => "\xff"}],
+        expected_error_records: [],
+        expected_errors: [],
+      },
+      "US-ASCII with default" => {
+        records: [{"data" => "\xff".force_encoding("US-ASCII")}],
+        additional_config: "",
+        expected_records: [],
+        expected_error_records: [{"data" => "\xff".force_encoding("US-ASCII")}],
+        expected_errors: [ArgumentError.new("invalid byte sequence in US-ASCII")],
+      },
+      "US-ASCII with replace_invalid_sequence" => {
+        records: [{"data" => "\xff".force_encoding("US-ASCII")}],
+        additional_config: "replace_invalid_sequence",
+        expected_records: [{"message" => "?".force_encoding("US-ASCII")}],
+        expected_error_records: [],
+        expected_errors: [],
+      },
+      "US-ASCII with replace_invalid_sequence and reserve_data" => {
+        records: [{"data" => "\xff".force_encoding("US-ASCII")}],
+        additional_config: ["replace_invalid_sequence", "reserve_data"].join("\n"),
+        expected_records: [{"message" => "?".force_encoding("US-ASCII"), "data" => "\xff".force_encoding("US-ASCII")}],
+        expected_error_records: [],
+        expected_errors: [],
+      },
+    )
+    def test_invalid_byte(data)
+      driver = create_driver(<<~EOC)
+        key_name data
+        #{data[:additional_config]}
+        <parse>
+          @type regexp
+          expression /^(?<message>.*)$/
+        </parse>
+      EOC
+
+      run_and_assert(driver, **data.except(:additional_config))
+    end
+
+    test "replace_invalid_sequence should be applied only to invalid byte sequence errors" do
+      error_msg = "This is a dummy ArgumentError other than invalid byte sequence"
+      any_instance_of(Fluent::Plugin::JSONParser) do |klass|
+        stub(klass).parse do
+          raise ArgumentError, error_msg
+        end
+      end
+
+      driver = create_driver(<<~EOC)
+        key_name data
+        replace_invalid_sequence
+        <parse>
+          @type json
+        </parse>
+      EOC
+
+      # replace_invalid_sequence should not applied
+      run_and_assert(
+        driver, 
+        records: [{'data' => '{"foo":"bar"}'}],
+        expected_records: [],
+        expected_error_records: [{'data' => '{"foo":"bar"}'}],
+        expected_errors: [ArgumentError.new(error_msg)]
+      )
+    end
   end
 end

From db10c6e855386a42e6ab06a34ca56994a80957c1 Mon Sep 17 00:00:00 2001
From: Daijiro Fukuda <fukuda@clear-code.com>
Date: Tue, 26 Nov 2024 14:32:23 +0900
Subject: [PATCH 3/5] ci: filter_parser: reorganize key not exist tests

Signed-off-by: Daijiro Fukuda <fukuda@clear-code.com>
---
 test/plugin/test_filter_parser.rb | 92 ++++++++++++++++---------------
 1 file changed, 49 insertions(+), 43 deletions(-)

diff --git a/test/plugin/test_filter_parser.rb b/test/plugin/test_filter_parser.rb
index c6ef507d80..4cee3d396c 100644
--- a/test/plugin/test_filter_parser.rb
+++ b/test/plugin/test_filter_parser.rb
@@ -538,38 +538,6 @@ def test_time_should_be_reserved(conf)
     assert_equal t, filtered[2][0]
   end
 
-  CONFIG_NOT_IGNORE = %[
-    key_name data
-    hash_value_field parsed
-    <parse>
-      @type json
-    </parse>
-  ]
-  CONFIG_PASS_SAME_RECORD = CONFIG_NOT_IGNORE + %[
-    reserve_data true
-  ]
-  def test_filter_key_not_exist
-    d = create_driver(CONFIG_NOT_IGNORE)
-    flexmock(d.instance.router).should_receive(:emit_error_event).
-      with(String, Integer, Hash, ArgumentError.new("data does not exist")).once
-    assert_nothing_raised {
-      d.run do
-        d.feed(@tag, Fluent::EventTime.now.to_i, {'foo' => 'bar'})
-      end
-    }
-
-    d = create_driver(CONFIG_PASS_SAME_RECORD)
-    assert_nothing_raised {
-      d.run do
-        d.feed(@tag, Fluent::EventTime.now.to_i, {'foo' => 'bar'})
-      end
-    }
-    filtered = d.filtered
-    assert_equal 1, filtered.length
-    assert_nil filtered[0][1]['data']
-    assert_equal 'bar', filtered[0][1]['foo']
-  end
-
   # emit_error_event test
   INVALID_MESSAGE = 'foo bar'
   VALID_MESSAGE   = 'col1=foo col2=bar'
@@ -614,17 +582,6 @@ def test_pattern_is_mismached_with_emit_invalid_record_to_error
       }
       assert_equal 0, d.filtered.length
     end
-
-    def test_key_not_exist_with_emit_invalid_record_to_error
-      d = create_driver(CONFIG_NOT_IGNORE + "emit_invalid_record_to_error false")
-      flexmock(d.instance.router).should_receive(:emit_error_event).never
-      assert_nothing_raised {
-        d.run do
-          d.feed(@tag, Fluent::EventTime.now.to_i, {'foo' => 'bar'})
-        end
-      }
-      assert_equal 0, d.filtered.length
-    end
   end
 
   sub_test_case "abnormal cases" do
@@ -662,6 +619,55 @@ def run_and_assert(driver, records:, expected_records:, expected_error_records:,
       )
     end
 
+    data(
+      "with default" => {
+        records: [{"foo" => "bar"}],
+        additional_config: "",
+        expected_records: [],
+        expected_error_records: [{"foo" => "bar"}],
+        expected_errors: [ArgumentError.new("data does not exist")],
+      },
+      "with reserve_data" => {
+        records: [{"foo" => "bar"}],
+        additional_config: "reserve_data",
+        expected_records: [{"foo" => "bar"}],
+        expected_error_records: [{"foo" => "bar"}],
+        expected_errors: [ArgumentError.new("data does not exist")],
+      },
+      "with disabled emit_invalid_record_to_error" => {
+        records: [{"foo" => "bar"}],
+        additional_config: "emit_invalid_record_to_error false",
+        expected_records: [],
+        expected_error_records: [],
+        expected_errors: [],
+      },
+      "with reserve_data and disabled emit_invalid_record_to_error" => {
+        records: [{"foo" => "bar"}],
+        additional_config: ["reserve_data", "emit_invalid_record_to_error false"].join("\n"),
+        expected_records: [{"foo" => "bar"}],
+        expected_error_records: [],
+        expected_errors: [],
+      },
+      "with reserve_data and hash_value_field" => {
+        records: [{"foo" => "bar"}],
+        additional_config: ["reserve_data", "hash_value_field parsed"].join("\n"),
+        expected_records: [{"foo" => "bar", "parsed" => {}}],
+        expected_error_records: [{"foo" => "bar"}],
+        expected_errors: [ArgumentError.new("data does not exist")],
+      },
+    )
+    def test_filter_key_not_exist(data)
+      driver = create_driver(<<~EOC)
+        key_name data
+        #{data[:additional_config]}
+        <parse>
+          @type json
+        </parse>
+      EOC
+
+      run_and_assert(driver, **data.except(:additional_config))
+    end
+
     data(
       "invalid format with default" => {
         records: [{'data' => '{"time":[], "f1":"v1"}'}],

From 08c98dcd5ecd46c95056d79a9cc47dec439f40d0 Mon Sep 17 00:00:00 2001
From: Daijiro Fukuda <fukuda@clear-code.com>
Date: Tue, 26 Nov 2024 14:39:05 +0900
Subject: [PATCH 4/5] ci: filter_parser: reorganize unmatched pattern tests

Signed-off-by: Daijiro Fukuda <fukuda@clear-code.com>
---
 test/plugin/test_filter_parser.rb | 99 ++++++++++++++++---------------
 1 file changed, 50 insertions(+), 49 deletions(-)

diff --git a/test/plugin/test_filter_parser.rb b/test/plugin/test_filter_parser.rb
index 4cee3d396c..b8a7f1cf49 100644
--- a/test/plugin/test_filter_parser.rb
+++ b/test/plugin/test_filter_parser.rb
@@ -2,11 +2,8 @@
 require 'timecop'
 require 'fluent/test/driver/filter'
 require 'fluent/plugin/filter_parser'
-require 'flexmock/test_unit'
 
 class ParserFilterTest < Test::Unit::TestCase
-  include FlexMock::TestCase
-
   def setup
     Fluent::Test.setup
     @tag = 'test'
@@ -538,52 +535,6 @@ def test_time_should_be_reserved(conf)
     assert_equal t, filtered[2][0]
   end
 
-  # emit_error_event test
-  INVALID_MESSAGE = 'foo bar'
-  VALID_MESSAGE   = 'col1=foo col2=bar'
-
-  CONFIG_UNMATCHED_PATTERN_LOG = %[
-    key_name message
-    <parse>
-      @type regexp
-      expression /^col1=(?<col1>.+) col2=(?<col2>.+)$/
-    </parse>
-  ]
-
-  class UnmatchedPatternLogTest < self
-    setup do
-      @d = create_driver(CONFIG_UNMATCHED_PATTERN_LOG)
-    end
-
-    def test_call_emit_error_event_when_pattern_is_mismached
-      flexmock(@d.instance.router).should_receive(:emit_error_event).
-        with(String, Integer, Hash, ParserError.new("pattern not matched with data '#{INVALID_MESSAGE}'")).once
-      @d.run do
-        @d.feed(@tag, Fluent::EventTime.now.to_i, {'message' => INVALID_MESSAGE})
-      end
-    end
-
-    def test_not_call_emit_error_event_when_pattern_is_mached
-      flexmock(@d.instance.router).should_receive(:emit_error_event).never
-      @d.run do
-        @d.feed(@tag, Fluent::EventTime.now.to_i, {'message' => VALID_MESSAGE})
-      end
-    end
-  end
-
-  class EmitInvalidRecordToErrorTest < self
-    def test_pattern_is_mismached_with_emit_invalid_record_to_error
-      d = create_driver(CONFIG_UNMATCHED_PATTERN_LOG + "emit_invalid_record_to_error false")
-      flexmock(d.instance.router).should_receive(:emit_error_event).never
-      assert_nothing_raised {
-        d.run do
-          d.feed(@tag, Fluent::EventTime.now.to_i, {'message' => INVALID_MESSAGE})
-        end
-      }
-      assert_equal 0, d.filtered.length
-    end
-  end
-
   sub_test_case "abnormal cases" do
     module HashExcept
       refine Hash do
@@ -668,6 +619,56 @@ def test_filter_key_not_exist(data)
       run_and_assert(driver, **data.except(:additional_config))
     end
 
+    data(
+      "with default" => {
+        records: [{"data" => "foo bar"}],
+        additional_config: "",
+        expected_records: [],
+        expected_error_records: [{"data" => "foo bar"}],
+        expected_errors: [Fluent::Plugin::Parser::ParserError.new("pattern not matched with data 'foo bar'")],
+      },
+      "with reserve_data" => {
+        records: [{"data" => "foo bar"}],
+        additional_config: "reserve_data",
+        expected_records: [{"data" => "foo bar"}],
+        expected_error_records: [{"data" => "foo bar"}],
+        expected_errors: [Fluent::Plugin::Parser::ParserError.new("pattern not matched with data 'foo bar'")],
+      },
+      "with disabled emit_invalid_record_to_error" => {
+        records: [{"data" => "foo bar"}],
+        additional_config: "emit_invalid_record_to_error false",
+        expected_records: [],
+        expected_error_records: [],
+        expected_errors: [],
+      },
+      "with reserve_data and disabled emit_invalid_record_to_error" => {
+        records: [{"data" => "foo bar"}],
+        additional_config: ["reserve_data", "emit_invalid_record_to_error false"].join("\n"),
+        expected_records: [{"data" => "foo bar"}],
+        expected_error_records: [],
+        expected_errors: [],
+      },
+      "with matched pattern" => {
+        records: [{"data" => "col1=foo col2=bar"}],
+        additional_config: "",
+        expected_records: [{"col1" => "foo", "col2" => "bar"}],
+        expected_error_records: [],
+        expected_errors: [],
+      },
+    )
+    def test_pattern_not_matched(data)
+      driver = create_driver(<<~EOC)
+        key_name data
+        #{data[:additional_config]}
+        <parse>
+          @type regexp
+          expression /^col1=(?<col1>.+) col2=(?<col2>.+)$/
+        </parse>
+      EOC
+
+      run_and_assert(driver, **data.except(:additional_config))
+    end
+
     data(
       "invalid format with default" => {
         records: [{'data' => '{"time":[], "f1":"v1"}'}],

From 788417d9922162bcf24be5ea68887e5a9e7262ab Mon Sep 17 00:00:00 2001
From: Daijiro Fukuda <fukuda@clear-code.com>
Date: Tue, 26 Nov 2024 14:39:26 +0900
Subject: [PATCH 5/5] ci: filter_parser: add unassumed error tests

Signed-off-by: Daijiro Fukuda <fukuda@clear-code.com>
---
 test/plugin/test_filter_parser.rb | 34 +++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/test/plugin/test_filter_parser.rb b/test/plugin/test_filter_parser.rb
index b8a7f1cf49..3b538798b6 100644
--- a/test/plugin/test_filter_parser.rb
+++ b/test/plugin/test_filter_parser.rb
@@ -786,5 +786,39 @@ def test_invalid_byte(data)
         expected_errors: [ArgumentError.new(error_msg)]
       )
     end
+
+    data(
+      "with default" => {
+        records: [{'data' => '{"foo":"bar"}'}],
+        additional_config: "",
+        expected_records: [],
+        expected_error_records: [{'data' => '{"foo":"bar"}'}],
+        expected_errors: [Fluent::Plugin::Parser::ParserError.new("parse failed This is a dummy unassumed error")],
+      },
+      "with disabled emit_invalid_record_to_error" => {
+        records: [{'data' => '{"foo":"bar"}'}],
+        additional_config: "emit_invalid_record_to_error false",
+        expected_records: [],
+        expected_error_records: [],
+        expected_errors: [],
+      },
+    )
+    def test_unassumed_error(data)
+      any_instance_of(Fluent::Plugin::JSONParser) do |klass|
+        stub(klass).parse do
+          raise RuntimeError, "This is a dummy unassumed error"
+        end
+      end
+
+      driver = create_driver(<<~EOC)
+        key_name data
+        #{data[:additional_config]}
+        <parse>
+          @type json
+        </parse>
+      EOC
+
+      run_and_assert(driver, **data.except(:additional_config))
+    end
   end
 end