liquid 4.0.0 → 5.0.1

data/test/integration/variable_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class VariableTest < Minitest::Test
@@ -5,88 +7,101 @@ class VariableTest < Minitest::Test
 
   def test_simple_variable
     template = Template.parse(%({{test}}))
-    assert_equal 'worked', template.render!('test' => 'worked')
-    assert_equal 'worked wonderfully', template.render!('test' => 'worked wonderfully')
+    assert_equal('worked', template.render!('test' => 'worked'))
+    assert_equal('worked wonderfully', template.render!('test' => 'worked wonderfully'))
   end
 
   def test_variable_render_calls_to_liquid
-    assert_template_result 'foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new
+    assert_template_result('foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new)
   end
 
   def test_simple_with_whitespaces
     template = Template.parse(%(  {{ test }}  ))
-    assert_equal '  worked  ', template.render!('test' => 'worked')
-    assert_equal '  worked wonderfully  ', template.render!('test' => 'worked wonderfully')
+    assert_equal('  worked  ', template.render!('test' => 'worked'))
+    assert_equal('  worked wonderfully  ', template.render!('test' => 'worked wonderfully'))
+  end
+
+  def test_expression_with_whitespace_in_square_brackets
+    assert_template_result('result', "{{ a[ 'b' ] }}", 'a' => { 'b' => 'result' })
+    assert_template_result('result', "{{ a[ [ 'b' ] ] }}", 'b' => 'c', 'a' => { 'c' => 'result' })
   end
 
   def test_ignore_unknown
     template = Template.parse(%({{ test }}))
-    assert_equal '', template.render!
+    assert_equal('', template.render!)
   end
 
   def test_using_blank_as_variable_name
     template = Template.parse("{% assign foo = blank %}{{ foo }}")
-    assert_equal '', template.render!
+    assert_equal('', template.render!)
   end
 
   def test_using_empty_as_variable_name
     template = Template.parse("{% assign foo = empty %}{{ foo }}")
-    assert_equal '', template.render!
+    assert_equal('', template.render!)
   end
 
   def test_hash_scoping
-    template = Template.parse(%({{ test.test }}))
-    assert_equal 'worked', template.render!('test' => { 'test' => 'worked' })
+    assert_template_result('worked', "{{ test.test }}", 'test' => { 'test' => 'worked' })
+    assert_template_result('worked', "{{ test . test }}", 'test' => { 'test' => 'worked' })
   end
 
   def test_false_renders_as_false
-    assert_equal 'false', Template.parse("{{ foo }}").render!('foo' => false)
-    assert_equal 'false', Template.parse("{{ false }}").render!
+    assert_equal('false', Template.parse("{{ foo }}").render!('foo' => false))
+    assert_equal('false', Template.parse("{{ false }}").render!)
   end
 
   def test_nil_renders_as_empty_string
-    assert_equal '', Template.parse("{{ nil }}").render!
-    assert_equal 'cat', Template.parse("{{ nil | append: 'cat' }}").render!
+    assert_equal('', Template.parse("{{ nil }}").render!)
+    assert_equal('cat', Template.parse("{{ nil | append: 'cat' }}").render!)
   end
 
   def test_preset_assigns
-    template = Template.parse(%({{ test }}))
+    template                 = Template.parse(%({{ test }}))
     template.assigns['test'] = 'worked'
-    assert_equal 'worked', template.render!
+    assert_equal('worked', template.render!)
   end
 
   def test_reuse_parsed_template
-    template = Template.parse(%({{ greeting }} {{ name }}))
+    template                     = Template.parse(%({{ greeting }} {{ name }}))
     template.assigns['greeting'] = 'Goodbye'
-    assert_equal 'Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi')
-    assert_equal 'Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi')
-    assert_equal 'Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian')
-    assert_equal 'Goodbye Brian', template.render!('name' => 'Brian')
+    assert_equal('Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi'))
+    assert_equal('Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi'))
+    assert_equal('Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian'))
+    assert_equal('Goodbye Brian', template.render!('name' => 'Brian'))
     assert_equal({ 'greeting' => 'Goodbye' }, template.assigns)
   end
 
   def test_assigns_not_polluted_from_template
-    template = Template.parse(%({{ test }}{% assign test = 'bar' %}{{ test }}))
+    template                 = Template.parse(%({{ test }}{% assign test = 'bar' %}{{ test }}))
     template.assigns['test'] = 'baz'
-    assert_equal 'bazbar', template.render!
-    assert_equal 'bazbar', template.render!
-    assert_equal 'foobar', template.render!('test' => 'foo')
-    assert_equal 'bazbar', template.render!
+    assert_equal('bazbar', template.render!)
+    assert_equal('bazbar', template.render!)
+    assert_equal('foobar', template.render!('test' => 'foo'))
+    assert_equal('bazbar', template.render!)
   end
 
   def test_hash_with_default_proc
-    template = Template.parse(%(Hello {{ test }}))
-    assigns = Hash.new { |h, k| raise "Unknown variable '#{k}'" }
+    template        = Template.parse(%(Hello {{ test }}))
+    assigns         = Hash.new { |_h, k| raise "Unknown variable '#{k}'" }
     assigns['test'] = 'Tobi'
-    assert_equal 'Hello Tobi', template.render!(assigns)
+    assert_equal('Hello Tobi', template.render!(assigns))
     assigns.delete('test')
     e = assert_raises(RuntimeError) do
       template.render!(assigns)
     end
-    assert_equal "Unknown variable 'test'", e.message
+    assert_equal("Unknown variable 'test'", e.message)
   end
 
   def test_multiline_variable
-    assert_equal 'worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked')
+    assert_equal('worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked'))
+  end
+
+  def test_render_symbol
+    assert_template_result('bar', '{{ foo }}', 'foo' => :bar)
+  end
+
+  def test_dynamic_find_var
+    assert_template_result('bar', '{{ [key] }}', 'key' => 'foo', 'foo' => 'bar')
   end
 end

data/test/test_helper.rb

@@ -1,21 +1,21 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 ENV["MT_NO_EXPECTATIONS"] = "1"
 require 'minitest/autorun'
-require 'spy/integration'
 
 $LOAD_PATH.unshift(File.join(File.expand_path(__dir__), '..', 'lib'))
 require 'liquid.rb'
 require 'liquid/profiler'
 
 mode = :strict
-if env_mode = ENV['LIQUID_PARSER_MODE']
+if (env_mode = ENV['LIQUID_PARSER_MODE'])
   puts "-- #{env_mode.upcase} ERROR MODE"
   mode = env_mode.to_sym
 end
 Liquid::Template.error_mode = mode
 
-if ENV['LIQUID-C'] == '1'
+if ENV['LIQUID_C'] == '1'
   puts "-- LIQUID C"
   require 'liquid/c'
 end
@@ -38,44 +38,55 @@ module Minitest
     include Liquid
 
     def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal expected, Template.parse(template).render!(assigns), message
+      assert_equal(expected, Template.parse(template, line_numbers: true).render!(assigns), message)
     end
 
     def assert_template_result_matches(expected, template, assigns = {}, message = nil)
-      return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
+      return assert_template_result(expected, template, assigns, message) unless expected.is_a?(Regexp)
 
-      assert_match expected, Template.parse(template).render!(assigns), message
+      assert_match(expected, Template.parse(template, line_numbers: true).render!(assigns), message)
     end
 
     def assert_match_syntax_error(match, template, assigns = {})
       exception = assert_raises(Liquid::SyntaxError) do
-        Template.parse(template).render(assigns)
+        Template.parse(template, line_numbers: true).render(assigns)
       end
-      assert_match match, exception.message
+      assert_match(match, exception.message)
+    end
+
+    def assert_usage_increment(name, times: 1)
+      old_method = Liquid::Usage.method(:increment)
+      calls = 0
+      begin
+        Liquid::Usage.singleton_class.send(:remove_method, :increment)
+        Liquid::Usage.define_singleton_method(:increment) do |got_name|
+          calls += 1 if got_name == name
+          old_method.call(got_name)
+        end
+        yield
+      ensure
+        Liquid::Usage.singleton_class.send(:remove_method, :increment)
+        Liquid::Usage.define_singleton_method(:increment, old_method)
+      end
+      assert_equal(times, calls, "Number of calls to Usage.increment with #{name.inspect}")
     end
 
     def with_global_filter(*globals)
-      original_global_strainer = Liquid::Strainer.class_variable_get(:@@global_strainer)
-      Liquid::Strainer.class_variable_set(:@@global_strainer, Class.new(Liquid::Strainer) do
-        @filter_methods = Set.new
-      end)
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
+      original_global_filters = Liquid::StrainerFactory.instance_variable_get(:@global_filters)
+      Liquid::StrainerFactory.instance_variable_set(:@global_filters, [])
+      globals.each do |global|
+        Liquid::StrainerFactory.add_global_filter(global)
+      end
+
+      Liquid::StrainerFactory.send(:strainer_class_cache).clear
 
       globals.each do |global|
         Liquid::Template.register_filter(global)
       end
       yield
     ensure
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
-      Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer)
-    end
-
-    def with_taint_mode(mode)
-      old_mode = Liquid::Template.taint_mode
-      Liquid::Template.taint_mode = mode
-      yield
-    ensure
-      Liquid::Template.taint_mode = old_mode
+      Liquid::StrainerFactory.send(:strainer_class_cache).clear
+      Liquid::StrainerFactory.instance_variable_set(:@global_filters, original_global_filters)
     end
 
     def with_error_mode(mode)
@@ -85,6 +96,20 @@ module Minitest
     ensure
       Liquid::Template.error_mode = old_mode
     end
+
+    def with_custom_tag(tag_name, tag_class)
+      old_tag = Liquid::Template.tags[tag_name]
+      begin
+        Liquid::Template.register_tag(tag_name, tag_class)
+        yield
+      ensure
+        if old_tag
+          Liquid::Template.tags[tag_name] = old_tag
+        else
+          Liquid::Template.tags.delete(tag_name)
+        end
+      end
+    end
   end
 end
 
@@ -115,3 +140,30 @@ class ErrorDrop < Liquid::Drop
     raise Exception, 'exception'
   end
 end
+
+class StubFileSystem
+  attr_reader :file_read_count
+
+  def initialize(values)
+    @file_read_count = 0
+    @values          = values
+  end
+
+  def read_template_file(template_path)
+    @file_read_count += 1
+    @values.fetch(template_path)
+  end
+end
+
+class StubTemplateFactory
+  attr_reader :count
+
+  def initialize
+    @count = 0
+  end
+
+  def for(_template_name)
+    @count += 1
+    Liquid::Template.new
+  end
+end

data/test/unit/block_unit_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class BlockUnitTest < Minitest::Test
@@ -5,49 +7,42 @@ class BlockUnitTest < Minitest::Test
 
   def test_blankspace
     template = Liquid::Template.parse("  ")
-    assert_equal ["  "], template.root.nodelist
+    assert_equal(["  "], template.root.nodelist)
   end
 
   def test_variable_beginning
     template = Liquid::Template.parse("{{funk}}  ")
-    assert_equal 2, template.root.nodelist.size
-    assert_equal Variable, template.root.nodelist[0].class
-    assert_equal String, template.root.nodelist[1].class
+    assert_equal(2, template.root.nodelist.size)
+    assert_equal(Variable, template.root.nodelist[0].class)
+    assert_equal(String, template.root.nodelist[1].class)
   end
 
   def test_variable_end
     template = Liquid::Template.parse("  {{funk}}")
-    assert_equal 2, template.root.nodelist.size
-    assert_equal String, template.root.nodelist[0].class
-    assert_equal Variable, template.root.nodelist[1].class
+    assert_equal(2, template.root.nodelist.size)
+    assert_equal(String, template.root.nodelist[0].class)
+    assert_equal(Variable, template.root.nodelist[1].class)
   end
 
   def test_variable_middle
     template = Liquid::Template.parse("  {{funk}}  ")
-    assert_equal 3, template.root.nodelist.size
-    assert_equal String, template.root.nodelist[0].class
-    assert_equal Variable, template.root.nodelist[1].class
-    assert_equal String, template.root.nodelist[2].class
+    assert_equal(3, template.root.nodelist.size)
+    assert_equal(String, template.root.nodelist[0].class)
+    assert_equal(Variable, template.root.nodelist[1].class)
+    assert_equal(String, template.root.nodelist[2].class)
   end
 
   def test_variable_many_embedded_fragments
     template = Liquid::Template.parse("  {{funk}} {{so}} {{brother}} ")
-    assert_equal 7, template.root.nodelist.size
-    assert_equal [String, Variable, String, Variable, String, Variable, String],
-      block_types(template.root.nodelist)
+    assert_equal(7, template.root.nodelist.size)
+    assert_equal([String, Variable, String, Variable, String, Variable, String],
+      block_types(template.root.nodelist))
   end
 
   def test_with_block
     template = Liquid::Template.parse("  {% comment %} {% endcomment %} ")
-    assert_equal [String, Comment, String], block_types(template.root.nodelist)
-    assert_equal 3, template.root.nodelist.size
-  end
-
-  def test_with_custom_tag
-    Liquid::Template.register_tag("testtag", Block)
-    assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
-  ensure
-    Liquid::Template.tags.delete('testtag')
+    assert_equal([String, Comment, String], block_types(template.root.nodelist))
+    assert_equal(3, template.root.nodelist.size)
   end
 
   private
@@ -55,4 +50,4 @@ class BlockUnitTest < Minitest::Test
   def block_types(nodelist)
     nodelist.collect(&:class)
   end
-end # VariableTest
+end

data/test/unit/condition_unit_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class ConditionUnitTest < Minitest::Test
@@ -8,146 +10,154 @@ class ConditionUnitTest < Minitest::Test
   end
 
   def test_basic_condition
-    assert_equal false, Condition.new(1, '==', 2).evaluate
-    assert_equal true,  Condition.new(1, '==', 1).evaluate
+    assert_equal(false, Condition.new(1, '==', 2).evaluate)
+    assert_equal(true,  Condition.new(1, '==', 1).evaluate)
   end
 
   def test_default_operators_evalute_true
-    assert_evaluates_true 1, '==', 1
-    assert_evaluates_true 1, '!=', 2
-    assert_evaluates_true 1, '<>', 2
-    assert_evaluates_true 1, '<', 2
-    assert_evaluates_true 2, '>', 1
-    assert_evaluates_true 1, '>=', 1
-    assert_evaluates_true 2, '>=', 1
-    assert_evaluates_true 1, '<=', 2
-    assert_evaluates_true 1, '<=', 1
+    assert_evaluates_true(1, '==', 1)
+    assert_evaluates_true(1, '!=', 2)
+    assert_evaluates_true(1, '<>', 2)
+    assert_evaluates_true(1, '<', 2)
+    assert_evaluates_true(2, '>', 1)
+    assert_evaluates_true(1, '>=', 1)
+    assert_evaluates_true(2, '>=', 1)
+    assert_evaluates_true(1, '<=', 2)
+    assert_evaluates_true(1, '<=', 1)
     # negative numbers
-    assert_evaluates_true 1, '>', -1
-    assert_evaluates_true (-1), '<', 1
-    assert_evaluates_true 1.0, '>', -1.0
-    assert_evaluates_true (-1.0), '<', 1.0
+    assert_evaluates_true(1, '>', -1)
+    assert_evaluates_true(-1, '<', 1)
+    assert_evaluates_true(1.0, '>', -1.0)
+    assert_evaluates_true(-1.0, '<', 1.0)
   end
 
   def test_default_operators_evalute_false
-    assert_evaluates_false 1, '==', 2
-    assert_evaluates_false 1, '!=', 1
-    assert_evaluates_false 1, '<>', 1
-    assert_evaluates_false 1, '<', 0
-    assert_evaluates_false 2, '>', 4
-    assert_evaluates_false 1, '>=', 3
-    assert_evaluates_false 2, '>=', 4
-    assert_evaluates_false 1, '<=', 0
-    assert_evaluates_false 1, '<=', 0
+    assert_evaluates_false(1, '==', 2)
+    assert_evaluates_false(1, '!=', 1)
+    assert_evaluates_false(1, '<>', 1)
+    assert_evaluates_false(1, '<', 0)
+    assert_evaluates_false(2, '>', 4)
+    assert_evaluates_false(1, '>=', 3)
+    assert_evaluates_false(2, '>=', 4)
+    assert_evaluates_false(1, '<=', 0)
+    assert_evaluates_false(1, '<=', 0)
   end
 
   def test_contains_works_on_strings
-    assert_evaluates_true 'bob', 'contains', 'o'
-    assert_evaluates_true 'bob', 'contains', 'b'
-    assert_evaluates_true 'bob', 'contains', 'bo'
-    assert_evaluates_true 'bob', 'contains', 'ob'
-    assert_evaluates_true 'bob', 'contains', 'bob'
+    assert_evaluates_true('bob', 'contains', 'o')
+    assert_evaluates_true('bob', 'contains', 'b')
+    assert_evaluates_true('bob', 'contains', 'bo')
+    assert_evaluates_true('bob', 'contains', 'ob')
+    assert_evaluates_true('bob', 'contains', 'bob')
 
-    assert_evaluates_false 'bob', 'contains', 'bob2'
-    assert_evaluates_false 'bob', 'contains', 'a'
-    assert_evaluates_false 'bob', 'contains', '---'
+    assert_evaluates_false('bob', 'contains', 'bob2')
+    assert_evaluates_false('bob', 'contains', 'a')
+    assert_evaluates_false('bob', 'contains', '---')
   end
 
   def test_invalid_comparation_operator
-    assert_evaluates_argument_error 1, '~~', 0
+    assert_evaluates_argument_error(1, '~~', 0)
   end
 
   def test_comparation_of_int_and_str
-    assert_evaluates_argument_error '1', '>', 0
-    assert_evaluates_argument_error '1', '<', 0
-    assert_evaluates_argument_error '1', '>=', 0
-    assert_evaluates_argument_error '1', '<=', 0
+    assert_evaluates_argument_error('1', '>', 0)
+    assert_evaluates_argument_error('1', '<', 0)
+    assert_evaluates_argument_error('1', '>=', 0)
+    assert_evaluates_argument_error('1', '<=', 0)
+  end
+
+  def test_hash_compare_backwards_compatibility
+    assert_nil(Condition.new({}, '>', 2).evaluate)
+    assert_nil(Condition.new(2, '>', {}).evaluate)
+    assert_equal(false, Condition.new({}, '==', 2).evaluate)
+    assert_equal(true, Condition.new({ 'a' => 1 }, '==', 'a' => 1).evaluate)
+    assert_equal(true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate)
   end
 
   def test_contains_works_on_arrays
-    @context = Liquid::Context.new
+    @context          = Liquid::Context.new
     @context['array'] = [1, 2, 3, 4, 5]
-    array_expr = VariableLookup.new("array")
+    array_expr        = VariableLookup.new("array")
 
-    assert_evaluates_false array_expr, 'contains', 0
-    assert_evaluates_true array_expr, 'contains', 1
-    assert_evaluates_true array_expr, 'contains', 2
-    assert_evaluates_true array_expr, 'contains', 3
-    assert_evaluates_true array_expr, 'contains', 4
-    assert_evaluates_true array_expr, 'contains', 5
-    assert_evaluates_false array_expr, 'contains', 6
-    assert_evaluates_false array_expr, 'contains', "1"
+    assert_evaluates_false(array_expr, 'contains', 0)
+    assert_evaluates_true(array_expr, 'contains', 1)
+    assert_evaluates_true(array_expr, 'contains', 2)
+    assert_evaluates_true(array_expr, 'contains', 3)
+    assert_evaluates_true(array_expr, 'contains', 4)
+    assert_evaluates_true(array_expr, 'contains', 5)
+    assert_evaluates_false(array_expr, 'contains', 6)
+    assert_evaluates_false(array_expr, 'contains', "1")
   end
 
   def test_contains_returns_false_for_nil_operands
     @context = Liquid::Context.new
-    assert_evaluates_false VariableLookup.new('not_assigned'), 'contains', '0'
-    assert_evaluates_false 0, 'contains', VariableLookup.new('not_assigned')
+    assert_evaluates_false(VariableLookup.new('not_assigned'), 'contains', '0')
+    assert_evaluates_false(0, 'contains', VariableLookup.new('not_assigned'))
   end
 
   def test_contains_return_false_on_wrong_data_type
-    assert_evaluates_false 1, 'contains', 0
+    assert_evaluates_false(1, 'contains', 0)
   end
 
   def test_contains_with_string_left_operand_coerces_right_operand_to_string
-    assert_evaluates_true ' 1 ', 'contains', 1
-    assert_evaluates_false ' 1 ', 'contains', 2
+    assert_evaluates_true(' 1 ', 'contains', 1)
+    assert_evaluates_false(' 1 ', 'contains', 2)
   end
 
   def test_or_condition
     condition = Condition.new(1, '==', 2)
 
-    assert_equal false, condition.evaluate
+    assert_equal(false, condition.evaluate)
 
-    condition.or Condition.new(2, '==', 1)
+    condition.or(Condition.new(2, '==', 1))
 
-    assert_equal false, condition.evaluate
+    assert_equal(false, condition.evaluate)
 
-    condition.or Condition.new(1, '==', 1)
+    condition.or(Condition.new(1, '==', 1))
 
-    assert_equal true, condition.evaluate
+    assert_equal(true, condition.evaluate)
   end
 
   def test_and_condition
     condition = Condition.new(1, '==', 1)
 
-    assert_equal true, condition.evaluate
+    assert_equal(true, condition.evaluate)
 
-    condition.and Condition.new(2, '==', 2)
+    condition.and(Condition.new(2, '==', 2))
 
-    assert_equal true, condition.evaluate
+    assert_equal(true, condition.evaluate)
 
-    condition.and Condition.new(2, '==', 1)
+    condition.and(Condition.new(2, '==', 1))
 
-    assert_equal false, condition.evaluate
+    assert_equal(false, condition.evaluate)
   end
 
   def test_should_allow_custom_proc_operator
-    Condition.operators['starts_with'] = proc { |cond, left, right| left =~ %r{^#{right}} }
+    Condition.operators['starts_with'] = proc { |_cond, left, right| left =~ /^#{right}/ }
 
-    assert_evaluates_true 'bob', 'starts_with', 'b'
-    assert_evaluates_false 'bob', 'starts_with', 'o'
+    assert_evaluates_true('bob', 'starts_with', 'b')
+    assert_evaluates_false('bob', 'starts_with', 'o')
   ensure
-    Condition.operators.delete 'starts_with'
+    Condition.operators.delete('starts_with')
   end
 
   def test_left_or_right_may_contain_operators
-    @context = Liquid::Context.new
+    @context        = Liquid::Context.new
     @context['one'] = @context['another'] = "gnomeslab-and-or-liquid"
 
-    assert_evaluates_true VariableLookup.new("one"), '==', VariableLookup.new("another")
+    assert_evaluates_true(VariableLookup.new("one"), '==', VariableLookup.new("another"))
   end
 
   private
 
   def assert_evaluates_true(left, op, right)
-    assert Condition.new(left, op, right).evaluate(@context),
-      "Evaluated false: #{left} #{op} #{right}"
+    assert(Condition.new(left, op, right).evaluate(@context),
+      "Evaluated false: #{left} #{op} #{right}")
   end
 
   def assert_evaluates_false(left, op, right)
-    assert !Condition.new(left, op, right).evaluate(@context),
-      "Evaluated true: #{left} #{op} #{right}"
+    assert(!Condition.new(left, op, right).evaluate(@context),
+      "Evaluated true: #{left} #{op} #{right}")
   end
 
   def assert_evaluates_argument_error(left, op, right)