spinto-liquid 2.3.0.1

data/test/liquid/drop_test.rb

@@ -0,0 +1,162 @@
+require 'test_helper'
+
+class ContextDrop < Liquid::Drop
+  def scopes
+    @context.scopes.size
+  end
+
+  def scopes_as_array
+    (1..@context.scopes.size).to_a
+  end
+
+  def loop_pos
+    @context['forloop.index']
+  end
+
+  def before_method(method)
+    return @context[method]
+  end
+end
+
+class ProductDrop < Liquid::Drop
+
+  class TextDrop < Liquid::Drop
+    def array
+      ['text1', 'text2']
+    end
+
+    def text
+      'text1'
+    end
+  end
+
+  class CatchallDrop < Liquid::Drop
+    def before_method(method)
+      return 'method: ' << method.to_s
+    end
+  end
+
+  def texts
+    TextDrop.new
+  end
+
+  def catchall
+    CatchallDrop.new
+  end
+
+  def context
+    ContextDrop.new
+  end
+
+  protected
+    def callmenot
+      "protected"
+    end
+end
+
+class EnumerableDrop < Liquid::Drop
+
+  def size
+    3
+  end
+
+  def each
+    yield 1
+    yield 2
+    yield 3
+  end
+end
+
+class DropsTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_product_drop
+
+    assert_nothing_raised do
+      tpl = Liquid::Template.parse( '  '  )
+      tpl.render('product' => ProductDrop.new)
+    end
+  end
+
+  def test_text_drop
+    output = Liquid::Template.parse( ' {{ product.texts.text }} '  ).render('product' => ProductDrop.new)
+    assert_equal ' text1 ', output
+
+  end
+
+  def test_unknown_method
+    output = Liquid::Template.parse( ' {{ product.catchall.unknown }} '  ).render('product' => ProductDrop.new)
+    assert_equal ' method: unknown ', output
+
+  end
+
+  def test_integer_argument_drop
+    output = Liquid::Template.parse( ' {{ product.catchall[8] }} '  ).render('product' => ProductDrop.new)
+    assert_equal ' method: 8 ', output
+  end
+
+  def test_text_array_drop
+    output = Liquid::Template.parse( '{% for text in product.texts.array %} {{text}} {% endfor %}'  ).render('product' => ProductDrop.new)
+    assert_equal ' text1  text2 ', output
+  end
+
+  def test_context_drop
+    output = Liquid::Template.parse( ' {{ context.bar }} '  ).render('context' => ContextDrop.new, 'bar' => "carrot")
+    assert_equal ' carrot ', output
+  end
+
+  def test_nested_context_drop
+    output = Liquid::Template.parse( ' {{ product.context.foo }} '  ).render('product' => ProductDrop.new, 'foo' => "monkey")
+    assert_equal ' monkey ', output
+  end
+
+  def test_protected
+    output = Liquid::Template.parse( ' {{ product.callmenot }} '  ).render('product' => ProductDrop.new)
+    assert_equal '  ', output
+  end
+
+  def test_scope
+    assert_equal '1', Liquid::Template.parse( '{{ context.scopes }}'  ).render('context' => ContextDrop.new)
+    assert_equal '2', Liquid::Template.parse( '{%for i in dummy%}{{ context.scopes }}{%endfor%}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '3', Liquid::Template.parse( '{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+  end
+
+  def test_scope_though_proc
+    assert_equal '1', Liquid::Template.parse( '{{ s }}'  ).render('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] })
+    assert_equal '2', Liquid::Template.parse( '{%for i in dummy%}{{ s }}{%endfor%}'  ).render('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] }, 'dummy' => [1])
+    assert_equal '3', Liquid::Template.parse( '{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}'  ).render('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] }, 'dummy' => [1])
+  end
+
+  def test_scope_with_assigns
+    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{{a}}'  ).render('context' => ContextDrop.new)
+    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal 'test', Liquid::Template.parse( '{% assign header_gif = "test"%}{{header_gif}}'  ).render('context' => ContextDrop.new)
+    assert_equal 'test', Liquid::Template.parse( "{% assign header_gif = 'test'%}{{header_gif}}"  ).render('context' => ContextDrop.new)
+  end
+
+  def test_scope_from_tags
+    assert_equal '1', Liquid::Template.parse( '{% for i in context.scopes_as_array %}{{i}}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '12', Liquid::Template.parse( '{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+  end
+
+  def test_access_context_from_drop
+    assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{{ context.loop_pos }}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1,2,3])
+  end
+
+  def test_enumerable_drop
+    assert_equal '123', Liquid::Template.parse( '{% for c in collection %}{{c}}{% endfor %}').render('collection' => EnumerableDrop.new)
+  end
+
+  def test_enumerable_drop_size
+    assert_equal '3', Liquid::Template.parse( '{{collection.size}}').render('collection' => EnumerableDrop.new)
+  end
+
+  def test_empty_string_value_access
+    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render('product' => ProductDrop.new, 'value' => '')
+  end
+
+  def test_nil_value_access
+    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render('product' => ProductDrop.new, 'value' => nil)
+  end
+end # DropsTest

data/test/liquid/error_handling_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+class ErrorDrop < Liquid::Drop
+  def standard_error
+    raise Liquid::StandardError, 'standard error'
+  end
+
+  def argument_error
+    raise Liquid::ArgumentError, 'argument error'
+  end
+
+  def syntax_error
+    raise Liquid::SyntaxError, 'syntax error'
+  end
+
+  def exception
+    raise Exception, 'exception'
+  end
+
+end
+
+class ErrorHandlingTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_standard_error
+    assert_nothing_raised do
+      template = Liquid::Template.parse( ' {{ errors.standard_error }} '  )
+      assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
+
+      assert_equal 1, template.errors.size
+      assert_equal StandardError, template.errors.first.class
+    end
+  end
+
+  def test_syntax
+
+    assert_nothing_raised do
+
+      template = Liquid::Template.parse( ' {{ errors.syntax_error }} '  )
+      assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
+
+      assert_equal 1, template.errors.size
+      assert_equal SyntaxError, template.errors.first.class
+
+    end
+  end
+
+  def test_argument
+    assert_nothing_raised do
+
+      template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
+      assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
+
+      assert_equal 1, template.errors.size
+      assert_equal ArgumentError, template.errors.first.class
+    end
+  end
+
+  def test_missing_endtag_parse_time_error
+    assert_raise(Liquid::SyntaxError) do
+      template = Liquid::Template.parse(' {% for a in b %} ... ')
+    end
+  end
+
+  def test_unrecognized_operator
+    assert_nothing_raised do
+      template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
+      assert_equal ' Liquid error: Unknown operator =! ', template.render
+      assert_equal 1, template.errors.size
+      assert_equal Liquid::ArgumentError, template.errors.first.class
+    end
+  end
+
+  # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
+  def test_exceptions_propagate
+    assert_raise Exception do
+      template = Liquid::Template.parse( ' {{ errors.exception }} '  )
+      template.render('errors' => ErrorDrop.new)
+    end
+  end
+end # ErrorHandlingTest

data/test/liquid/file_system_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class FileSystemTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_default
+    assert_raise(FileSystemError) do
+      BlankFileSystem.new.read_template_file("dummy", {'dummy'=>'smarty'})
+    end
+  end
+
+  def test_local
+    file_system = Liquid::LocalFileSystem.new("/some/path")
+    assert_equal "/some/path/_mypartial.liquid"    , file_system.full_path("mypartial")
+    assert_equal "/some/path/dir/_mypartial.liquid", file_system.full_path("dir/mypartial")
+
+    assert_raise(FileSystemError) do
+      file_system.full_path("../dir/mypartial")
+    end
+
+    assert_raise(FileSystemError) do
+      file_system.full_path("/dir/../../dir/mypartial")
+    end
+
+    assert_raise(FileSystemError) do
+      file_system.full_path("/etc/passwd")
+    end
+  end
+end # FileSystemTest

data/test/liquid/filter_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+
+module MoneyFilter
+  def money(input)
+    sprintf(' %d$ ', input)
+  end
+
+  def money_with_underscore(input)
+    sprintf(' %d$ ', input)
+  end
+end
+
+module CanadianMoneyFilter
+  def money(input)
+    sprintf(' %d$ CAD ', input)
+  end
+end
+
+class FiltersTest < Test::Unit::TestCase
+  include Liquid
+
+  def setup
+    @context = Context.new
+  end
+
+  def test_local_filter
+    @context['var'] = 1000
+    @context.add_filters(MoneyFilter)
+
+    assert_equal ' 1000$ ', Variable.new("var | money").render(@context)
+  end
+
+  def test_underscore_in_filter_name
+    @context['var'] = 1000
+    @context.add_filters(MoneyFilter)
+    assert_equal ' 1000$ ', Variable.new("var | money_with_underscore").render(@context)
+  end
+
+  def test_second_filter_overwrites_first
+    @context['var'] = 1000
+    @context.add_filters(MoneyFilter)
+    @context.add_filters(CanadianMoneyFilter)
+
+    assert_equal ' 1000$ CAD ', Variable.new("var | money").render(@context)
+  end
+
+  def test_size
+    @context['var'] = 'abcd'
+    @context.add_filters(MoneyFilter)
+
+    assert_equal 4, Variable.new("var | size").render(@context)
+  end
+
+  def test_join
+    @context['var'] = [1,2,3,4]
+
+    assert_equal "1 2 3 4", Variable.new("var | join").render(@context)
+  end
+
+  def test_sort
+    @context['value'] = 3
+    @context['numbers'] = [2,1,4,3]
+    @context['words'] = ['expected', 'as', 'alphabetic']
+    @context['arrays'] = [['flattened'], ['are']]
+
+    assert_equal [1,2,3,4], Variable.new("numbers | sort").render(@context)
+    assert_equal ['alphabetic', 'as', 'expected'], Variable.new("words | sort").render(@context)
+    assert_equal [3], Variable.new("value | sort").render(@context)
+    assert_equal ['are', 'flattened'], Variable.new("arrays | sort").render(@context)
+  end
+
+  def test_strip_html
+    @context['var'] = "<b>bla blub</a>"
+
+    assert_equal "bla blub", Variable.new("var | strip_html").render(@context)
+  end
+
+  def test_capitalize
+    @context['var'] = "blub"
+
+    assert_equal "Blub", Variable.new("var | capitalize").render(@context)
+  end
+
+  def test_nonexistent_filter_is_ignored
+    @context['var'] = 1000
+
+    assert_equal 1000, Variable.new("var | xyzzy").render(@context)
+  end
+end
+
+class FiltersInTemplate < Test::Unit::TestCase
+  include Liquid
+
+  def test_local_global
+    Template.register_filter(MoneyFilter)
+
+    assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render(nil, nil)
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, :filters => CanadianMoneyFilter)
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, :filters => [CanadianMoneyFilter])
+  end
+
+  def test_local_filter_with_deprecated_syntax
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, CanadianMoneyFilter)
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, [CanadianMoneyFilter])
+  end
+end # FiltersTest

data/test/liquid/module_ex_test.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+class TestClassA
+  liquid_methods :allowedA, :chainedB
+  def allowedA
+    'allowedA'
+  end
+  def restrictedA
+    'restrictedA'
+  end
+  def chainedB
+    TestClassB.new
+  end
+end
+
+class TestClassB
+  liquid_methods :allowedB, :chainedC
+  def allowedB
+    'allowedB'
+  end
+  def chainedC
+    TestClassC.new
+  end
+end
+
+class TestClassC
+  liquid_methods :allowedC
+  def allowedC
+    'allowedC'
+  end
+end
+
+class TestClassC::LiquidDropClass
+  def another_allowedC
+    'another_allowedC'
+  end
+end
+
+class ModuleExTest < Test::Unit::TestCase
+  include Liquid
+
+  def setup
+    @a = TestClassA.new
+    @b = TestClassB.new
+    @c = TestClassC.new
+  end
+
+  def test_should_create_LiquidDropClass
+    assert TestClassA::LiquidDropClass
+    assert TestClassB::LiquidDropClass
+    assert TestClassC::LiquidDropClass
+  end
+
+  def test_should_respond_to_liquid
+    assert @a.respond_to?(:to_liquid)
+    assert @b.respond_to?(:to_liquid)
+    assert @c.respond_to?(:to_liquid)
+  end
+
+  def test_should_return_LiquidDropClass_object
+    assert @a.to_liquid.is_a?(TestClassA::LiquidDropClass)
+    assert @b.to_liquid.is_a?(TestClassB::LiquidDropClass)
+    assert @c.to_liquid.is_a?(TestClassC::LiquidDropClass)
+  end
+
+  def test_should_respond_to_liquid_methods
+    assert @a.to_liquid.respond_to?(:allowedA)
+    assert @a.to_liquid.respond_to?(:chainedB)
+    assert @b.to_liquid.respond_to?(:allowedB)
+    assert @b.to_liquid.respond_to?(:chainedC)
+    assert @c.to_liquid.respond_to?(:allowedC)
+    assert @c.to_liquid.respond_to?(:another_allowedC)
+  end
+
+  def test_should_not_respond_to_restricted_methods
+    assert ! @a.to_liquid.respond_to?(:restricted)
+  end
+
+  def test_should_use_regular_objects_as_drops
+    assert_equal 'allowedA', Liquid::Template.parse("{{ a.allowedA }}").render('a'=>@a)
+    assert_equal 'allowedB', Liquid::Template.parse("{{ a.chainedB.allowedB }}").render('a'=>@a)
+    assert_equal 'allowedC', Liquid::Template.parse("{{ a.chainedB.chainedC.allowedC }}").render('a'=>@a)
+    assert_equal 'another_allowedC', Liquid::Template.parse("{{ a.chainedB.chainedC.another_allowedC }}").render('a'=>@a)
+    assert_equal '', Liquid::Template.parse("{{ a.restricted }}").render('a'=>@a)
+    assert_equal '', Liquid::Template.parse("{{ a.unknown }}").render('a'=>@a)
+  end
+end # ModuleExTest