Rename with_error_mode(...) to with_error_modes(...)

test/integration/context_test.rb

@@ -632,7 +632,7 @@ class ContextTest < Minitest::Test
   end
 
   def test_has_key_will_not_add_an_error_for_missing_keys
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       context = Context.new
       context.key?('unknown')
       assert_empty(context.errors)

test/integration/error_handling_test.rb

@@ -67,7 +67,7 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_unrecognized_operator
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       assert_raises(SyntaxError) do
         Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
       end

test/integration/expression_test.rb

@@ -27,7 +27,7 @@ class ExpressionTest < Minitest::Test
     assert_template_result("-17.42", "{{ -17.42 }}")
     assert_template_result("2.5", "{{ 2.5 }}")
 
-    with_error_mode(:lax) do
+    with_error_modes(:lax) do
       assert_expression_result(0.0, "0.....5")
       assert_expression_result(0.0, "-0..1")
     end

test/integration/parsing_quirks_test.rb

@@ -31,18 +31,18 @@ class ParsingQuirksTest < Minitest::Test
   def test_error_on_empty_filter
     assert(Template.parse("{{test}}"))
 
-    with_error_mode(:lax) do
+    with_error_modes(:lax) do
       assert(Template.parse("{{|test}}"))
     end
 
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       assert_raises(SyntaxError) { Template.parse("{{|test}}") }
       assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") }
     end
   end
 
   def test_meaningless_parens_error
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       assert_raises(SyntaxError) do
         markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
@@ -51,7 +51,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_unexpected_characters_syntax_error
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       assert_raises(SyntaxError) do
         markup = "true && false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
@@ -70,7 +70,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_meaningless_parens_lax
-    with_error_mode(:lax) do
+    with_error_modes(:lax) do
       assigns = { 'b' => 'bar', 'c' => 'baz' }
       markup  = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
       assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
@@ -78,7 +78,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_unexpected_characters_silently_eat_logic_lax
-    with_error_mode(:lax) do
+    with_error_modes(:lax) do
       markup = "true && false"
       assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
       markup = "false || true"
@@ -93,7 +93,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_unanchored_filter_arguments
-    with_error_mode(:lax) do
+    with_error_modes(:lax) do
       assert_template_result('hi', "{{ 'hi there' | split$$$:' ' | first }}")
 
       assert_template_result('x', "{{ 'X' | downcase) }}")
@@ -106,14 +106,14 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_invalid_variables_work
-    with_error_mode(:lax) do
+    with_error_modes(:lax) do
       assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
       assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
     end
   end
 
   def test_extra_dots_in_ranges
-    with_error_mode(:lax) do
+    with_error_modes(:lax) do
       assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
     end
   end
@@ -133,7 +133,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_incomplete_expression
-    with_error_mode(:lax) do
+    with_error_modes(:lax) do
       assert_template_result("false", "{{ false - }}")
       assert_template_result("false", "{{ false > }}")
       assert_template_result("false", "{{ false < }}")

test/integration/tags/cycle_tag_test.rb

@@ -96,12 +96,12 @@ class CycleTagTest < Minitest::Test
     template1 = "{% assign 5 = 'b' %}{% cycle .5, .4 %}"
     template2 = "{% cycle .5: 'a', 'b' %}"
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       assert_template_result("b", template1)
       assert_template_result("a", template2)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
       error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
 
@@ -121,7 +121,7 @@ class CycleTagTest < Minitest::Test
     template4 = "#{assignments}{% cycle n  e: 'a', 'b', 'c' %}"
     template5 = "#{assignments}{% cycle n  e  'a', 'b', 'c' %}"
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       assert_template_result("a", template1)
       assert_template_result("a", template2)
       assert_template_result("a", template3)
@@ -129,7 +129,7 @@ class CycleTagTest < Minitest::Test
       assert_template_result("N", template5)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
       error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
       error3 = assert_raises(Liquid::SyntaxError) { Template.parse(template3) }
@@ -153,11 +153,11 @@ class CycleTagTest < Minitest::Test
       {% endfor %}
     LIQUID
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       refute_nil(Template.parse(template))
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -170,11 +170,11 @@ class CycleTagTest < Minitest::Test
       {% endfor %}
     LIQUID
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       refute_nil(Template.parse(template))
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end

test/integration/tags/include_tag_test.rb

@@ -205,7 +205,7 @@ class IncludeTagTest < Minitest::Test
   end
 
   def test_rigid_parsing_errors
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       assert_template_result(
         'hello value1 value2',
         '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
@@ -213,7 +213,7 @@ class IncludeTagTest < Minitest::Test
       )
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_syntax_error(
         '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
       )
@@ -303,13 +303,13 @@ class IncludeTagTest < Minitest::Test
     assert_raises(Liquid::SyntaxError) do
       Template.parse("{% include template %}", error_mode: :strict, environment: env).render!("template" => '{{ "X" || downcase }}')
     end
-    with_error_mode(:lax) do
+    with_error_modes(:lax) do
       assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: true, environment: env).render!("template" => '{{ "X" || downcase }}'))
     end
     assert_raises(Liquid::SyntaxError) do
       Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:locale], environment: env).render!("template" => '{{ "X" || downcase }}')
     end
-    with_error_mode(:lax) do
+    with_error_modes(:lax) do
       assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode], environment: env).render!("template" => '{{ "X" || downcase }}'))
     end
   end
@@ -404,11 +404,11 @@ class IncludeTagTest < Minitest::Test
   def test_include_template_with_invalid_expression
     template = "{% include foo=>bar %}"
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       refute_nil(Template.parse(template))
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -417,11 +417,11 @@ class IncludeTagTest < Minitest::Test
   def test_include_with_invalid_expression
     template = '{% include "snippet" with foo=>bar %}'
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       refute_nil(Template.parse(template))
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -430,11 +430,11 @@ class IncludeTagTest < Minitest::Test
   def test_include_attribute_with_invalid_expression
     template = '{% include "snippet", key: foo=>bar %}'
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       refute_nil(Template.parse(template))
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end

test/integration/tags/render_tag_test.rb

@@ -106,7 +106,7 @@ class RenderTagTest < Minitest::Test
   end
 
   def test_rigid_parsing_errors
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       assert_template_result(
         'hello value1 value2',
         '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
@@ -114,7 +114,7 @@ class RenderTagTest < Minitest::Test
       )
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_syntax_error(
         '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
       )
@@ -318,11 +318,11 @@ class RenderTagTest < Minitest::Test
   def test_render_with_invalid_expression
     template = '{% render "snippet" with foo=>bar %}'
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       refute_nil(Template.parse(template))
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -331,11 +331,11 @@ class RenderTagTest < Minitest::Test
   def test_render_attribute_with_invalid_expression
     template = '{% render "snippet", key: foo=>bar %}'
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       refute_nil(Template.parse(template))
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end

test/integration/tags/table_row_test.rb

@@ -270,7 +270,7 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">4</td><td class="col2">5</td><td class="col3">6</td></tr>
     OUTPUT
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result(expected, template)
     end
   end
@@ -285,7 +285,7 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result(expected, template)
     end
   end
@@ -300,7 +300,7 @@ class TableRowTest < Minitest::Test
       <td class="col1">3</td><td class="col2">4</td><td class="col3">5</td></tr>
     OUTPUT
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result(expected, template)
     end
   end
@@ -315,7 +315,7 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result(expected, template)
     end
   end
@@ -331,7 +331,7 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">4</td><td class="col2">5</td></tr>
     OUTPUT
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result(expected, template)
     end
   end
@@ -347,7 +347,7 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
     OUTPUT
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result(expected, template, { 'numbers' => [1, 2, 3, 4] })
     end
   end
@@ -363,7 +363,7 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
     OUTPUT
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result(expected, template, { 'obj' => { 'numbers' => [1, 2, 3, 4] } })
     end
   end
@@ -378,7 +378,7 @@ class TableRowTest < Minitest::Test
       <td class="col1">10</td><td class="col2">20</td></tr>
     OUTPUT
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result(expected, template, { 'obj' => { 'numbers' => [10, 20] } })
     end
   end
@@ -393,7 +393,7 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result(expected, template)
     end
   end
@@ -401,7 +401,7 @@ class TableRowTest < Minitest::Test
   def test_tablerow_without_in_keyword_in_rigid_mode
     template = '{% tablerow i (1..10) %}{{ i }}{% endtablerow %}'
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(SyntaxError) { Template.parse(template) }
       assert_equal("Liquid syntax error: For loops require an 'in' clause in \"i (1..10)\"", error.message)
     end
@@ -410,7 +410,7 @@ class TableRowTest < Minitest::Test
   def test_tablerow_with_multiple_invalid_attributes_reports_first_in_rigid_mode
     template = '{% tablerow i in (1..10) invalid1: 5, invalid2: 10 %}{{ i }}{% endtablerow %}'
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(SyntaxError) { Template.parse(template) }
       assert_equal("Liquid syntax error: Invalid attribute 'invalid1' in tablerow loop. Valid attributes are cols, limit, offset, and range in \"i in (1..10) invalid1: 5, invalid2: 10\"", error.message)
     end
@@ -426,7 +426,7 @@ class TableRowTest < Minitest::Test
       </tr>
     OUTPUT
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result(expected, template, { 'empty_array' => [] })
     end
   end
@@ -439,11 +439,11 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td><td class="col4">4</td><td class="col5">5</td></tr>
     OUTPUT
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       assert_template_result(expected, template)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(SyntaxError) { Template.parse(template) }
       assert_match(/Invalid attribute 'invalid_attr'/, error.message)
     end
@@ -452,7 +452,7 @@ class TableRowTest < Minitest::Test
   def test_tablerow_with_invalid_expression_strict_vs_rigid
     template = '{% tablerow i in (1..5) limit: foo=>bar %}{{ i }}{% endtablerow %}'
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       expected = <<~OUTPUT
         <tr class="row1">
         </tr>
@@ -460,7 +460,7 @@ class TableRowTest < Minitest::Test
       assert_template_result(expected, template)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       # Rigid mode validates expression syntax and rejects invalid expressions
       error = assert_raises(SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)

test/integration/variable_test.rb

@@ -213,12 +213,12 @@ class VariableTest < Minitest::Test
   def test_filter_with_single_trailing_comma
     template = '{{ "hello" | append: "world", }}'
 
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result('helloworld', template)
     end
   end
@@ -226,12 +226,12 @@ class VariableTest < Minitest::Test
   def test_multiple_filters_with_trailing_commas
     template = '{{ "hello" | append: "1", | append: "2", }}'
 
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result('hello12', template)
     end
   end
@@ -239,12 +239,12 @@ class VariableTest < Minitest::Test
   def test_filter_with_colon_but_no_arguments
     template = '{{ "test" | upcase: }}'
 
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result('TEST', template)
     end
   end
@@ -252,12 +252,12 @@ class VariableTest < Minitest::Test
   def test_filter_chain_with_colon_no_args
     template = '{{ "test" | append: "x" | upcase: }}'
 
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result('TESTX', template)
     end
   end
@@ -265,12 +265,12 @@ class VariableTest < Minitest::Test
   def test_combining_trailing_comma_and_empty_args
     template = '{{ "test" | append: "x", | upcase: }}'
 
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       assert_template_result('TESTX', template)
     end
   end

test/test_helper.rb

@@ -82,7 +82,7 @@ module Minitest
       Environment.dangerously_override(environment, &blk)
     end
 
-    def with_error_mode(*modes)
+    def with_error_modes(*modes)
       old_mode = Liquid::Environment.default.error_mode
       modes.each do |mode|
         Liquid::Environment.default.error_mode = mode

test/unit/tags/case_tag_unit_test.rb

@@ -20,11 +20,11 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       assert_template_result("one", template)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Expected end_of_string but found/, error.message)
@@ -41,11 +41,11 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       assert_template_result("one", template)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Expected end_of_string but found/, error.message)
@@ -62,7 +62,7 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_mode(:lax, :strict, :rigid) do
+    with_error_modes(:lax, :strict, :rigid) do
       assert_template_result("one", template)
     end
   end
@@ -77,7 +77,7 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_mode(:lax, :strict, :rigid) do
+    with_error_modes(:lax, :strict, :rigid) do
       assert_template_result("one", template)
     end
   end
@@ -93,11 +93,11 @@ class CaseTagUnitTest < Minitest::Test
     LIQUID
     assigns = { 'foo' => { 'bar' => 'baz' } }
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       assert_template_result("one", template, assigns)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Unexpected character =/, error.message)
@@ -115,11 +115,11 @@ class CaseTagUnitTest < Minitest::Test
     LIQUID
     assigns = { 'foo' => { 'bar' => 'baz' } }
 
-    with_error_mode(:lax, :strict) do
+    with_error_modes(:lax, :strict) do
       assert_template_result("one", template, assigns)
     end
 
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Unexpected character =/, error.message)

test/unit/variable_unit_test.rb

@@ -108,7 +108,7 @@ class VariableUnitTest < Minitest::Test
     assert_equal(VariableLookup.new('foo-bar'), create_variable('foo-bar').name)
     assert_equal(VariableLookup.new('foo-bar-2'), create_variable('foo-bar-2').name)
 
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       assert_raises(Liquid::SyntaxError) { create_variable('foo - bar') }
       assert_raises(Liquid::SyntaxError) { create_variable('-foo') }
       assert_raises(Liquid::SyntaxError) { create_variable('2foo') }
@@ -154,7 +154,7 @@ class VariableUnitTest < Minitest::Test
   end
 
   def test_strict_filter_argument_parsing
-    with_error_mode(:strict) do
+    with_error_modes(:strict) do
       assert_raises(SyntaxError) do
         create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ))
       end
@@ -162,7 +162,7 @@ class VariableUnitTest < Minitest::Test
   end
 
   def test_rigid_filter_argument_parsing
-    with_error_mode(:rigid) do
+    with_error_modes(:rigid) do
       # optional colon
       var = create_variable(%(n | f1 | f2:))
       assert_equal([['f1', []], ['f2', []]], var.filters)