mirror of
https://github.com/Shopify/liquid.git
synced 2026-09-17 01:40:42 -07:00
Tests
- Organized the files - Cleaned up some of the white spacing issues - A lot can still be done to make the tests more readable to the new developers
This commit is contained in:
DBA
@@ -0,0 +1,15 @@
|
||||
require 'test_helper'
|
||||
|
||||
class AssignTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_assigned_variable
|
||||
assert_template_result('.foo.',
|
||||
'{% assign foo = values %}.{{ foo[0] }}.',
|
||||
'values' => %w{foo bar baz})
|
||||
|
||||
assert_template_result('.bar.',
|
||||
'{% assign foo = values %}.{{ foo[1] }}.',
|
||||
'values' => %w{foo bar baz})
|
||||
end
|
||||
end # AssignTest
|
||||
@@ -0,0 +1,58 @@
|
||||
require 'test_helper'
|
||||
|
||||
class VariableTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_blankspace
|
||||
template = Liquid::Template.parse(" ")
|
||||
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
|
||||
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
|
||||
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
|
||||
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)
|
||||
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_nothing_thrown do
|
||||
template = Liquid::Template.parse( "{% testtag %} {% endtesttag %}")
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
def block_types(nodelist)
|
||||
nodelist.collect { |node| node.class }
|
||||
end
|
||||
end # VariableTest
|
||||
@@ -0,0 +1,40 @@
|
||||
require 'test_helper'
|
||||
|
||||
class CaptureTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_captures_block_content_in_variable
|
||||
assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
|
||||
end
|
||||
|
||||
def test_capture_to_variable_from_outer_scope_if_existing
|
||||
template_source = <<-END_TEMPLATE
|
||||
{% assign var = '' %}
|
||||
{% if true %}
|
||||
{% capture var %}first-block-string{% endcapture %}
|
||||
{% endif %}
|
||||
{% if true %}
|
||||
{% capture var %}test-string{% endcapture %}
|
||||
{% endif %}
|
||||
{{var}}
|
||||
END_TEMPLATE
|
||||
template = Template.parse(template_source)
|
||||
rendered = template.render
|
||||
assert_equal "test-string", rendered.gsub(/\s/, '')
|
||||
end
|
||||
|
||||
def test_assigning_from_capture
|
||||
template_source = <<-END_TEMPLATE
|
||||
{% assign first = '' %}
|
||||
{% assign second = '' %}
|
||||
{% for number in (1..3) %}
|
||||
{% capture first %}{{number}}{% endcapture %}
|
||||
{% assign second = first %}
|
||||
{% endfor %}
|
||||
{{ first }}-{{ second }}
|
||||
END_TEMPLATE
|
||||
template = Template.parse(template_source)
|
||||
rendered = template.render
|
||||
assert_equal "3-3", rendered.gsub(/\s/, '')
|
||||
end
|
||||
end # CaptureTest
|
||||
@@ -0,0 +1,118 @@
|
||||
require 'test_helper'
|
||||
|
||||
class ConditionTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_basic_condition
|
||||
assert_equal false, Condition.new('1', '==', '2').evaluate
|
||||
assert_equal true, Condition.new('1', '==', '1').evaluate
|
||||
end
|
||||
|
||||
def test_default_operators_evalute_true
|
||||
assert_evalutes_true '1', '==', '1'
|
||||
assert_evalutes_true '1', '!=', '2'
|
||||
assert_evalutes_true '1', '<>', '2'
|
||||
assert_evalutes_true '1', '<', '2'
|
||||
assert_evalutes_true '2', '>', '1'
|
||||
assert_evalutes_true '1', '>=', '1'
|
||||
assert_evalutes_true '2', '>=', '1'
|
||||
assert_evalutes_true '1', '<=', '2'
|
||||
assert_evalutes_true '1', '<=', '1'
|
||||
end
|
||||
|
||||
def test_default_operators_evalute_false
|
||||
assert_evalutes_false '1', '==', '2'
|
||||
assert_evalutes_false '1', '!=', '1'
|
||||
assert_evalutes_false '1', '<>', '1'
|
||||
assert_evalutes_false '1', '<', '0'
|
||||
assert_evalutes_false '2', '>', '4'
|
||||
assert_evalutes_false '1', '>=', '3'
|
||||
assert_evalutes_false '2', '>=', '4'
|
||||
assert_evalutes_false '1', '<=', '0'
|
||||
assert_evalutes_false '1', '<=', '0'
|
||||
end
|
||||
|
||||
def test_contains_works_on_strings
|
||||
assert_evalutes_true "'bob'", 'contains', "'o'"
|
||||
assert_evalutes_true "'bob'", 'contains', "'b'"
|
||||
assert_evalutes_true "'bob'", 'contains', "'bo'"
|
||||
assert_evalutes_true "'bob'", 'contains', "'ob'"
|
||||
assert_evalutes_true "'bob'", 'contains', "'bob'"
|
||||
|
||||
assert_evalutes_false "'bob'", 'contains', "'bob2'"
|
||||
assert_evalutes_false "'bob'", 'contains', "'a'"
|
||||
assert_evalutes_false "'bob'", 'contains', "'---'"
|
||||
end
|
||||
|
||||
def test_contains_works_on_arrays
|
||||
@context = Liquid::Context.new
|
||||
@context['array'] = [1,2,3,4,5]
|
||||
|
||||
assert_evalutes_false "array", 'contains', '0'
|
||||
assert_evalutes_true "array", 'contains', '1'
|
||||
assert_evalutes_true "array", 'contains', '2'
|
||||
assert_evalutes_true "array", 'contains', '3'
|
||||
assert_evalutes_true "array", 'contains', '4'
|
||||
assert_evalutes_true "array", 'contains', '5'
|
||||
assert_evalutes_false "array", 'contains', '6'
|
||||
|
||||
assert_evalutes_false "array", 'contains', '"1"'
|
||||
|
||||
end
|
||||
|
||||
def test_contains_returns_false_for_nil_operands
|
||||
@context = Liquid::Context.new
|
||||
assert_evalutes_false "not_assigned", 'contains', '0'
|
||||
assert_evalutes_false "0", 'contains', 'not_assigned'
|
||||
end
|
||||
|
||||
def test_or_condition
|
||||
condition = Condition.new('1', '==', '2')
|
||||
|
||||
assert_equal false, condition.evaluate
|
||||
|
||||
condition.or Condition.new('2', '==', '1')
|
||||
|
||||
assert_equal false, condition.evaluate
|
||||
|
||||
condition.or Condition.new('1', '==', '1')
|
||||
|
||||
assert_equal true, condition.evaluate
|
||||
end
|
||||
|
||||
def test_and_condition
|
||||
condition = Condition.new('1', '==', '1')
|
||||
|
||||
assert_equal true, condition.evaluate
|
||||
|
||||
condition.and Condition.new('2', '==', '2')
|
||||
|
||||
assert_equal true, condition.evaluate
|
||||
|
||||
condition.and Condition.new('2', '==', '1')
|
||||
|
||||
assert_equal false, condition.evaluate
|
||||
end
|
||||
|
||||
|
||||
def test_should_allow_custom_proc_operator
|
||||
Condition.operators['starts_with'] = Proc.new { |cond, left, right| left =~ %r{^#{right}} }
|
||||
|
||||
assert_evalutes_true "'bob'", 'starts_with', "'b'"
|
||||
assert_evalutes_false "'bob'", 'starts_with', "'o'"
|
||||
|
||||
ensure
|
||||
Condition.operators.delete 'starts_with'
|
||||
end
|
||||
|
||||
private
|
||||
def assert_evalutes_true(left, op, right)
|
||||
assert Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
|
||||
"Evaluated false: #{left} #{op} #{right}"
|
||||
end
|
||||
|
||||
def assert_evalutes_false(left, op, right)
|
||||
assert !Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
|
||||
"Evaluated true: #{left} #{op} #{right}"
|
||||
end
|
||||
end # ConditionTest
|
||||
@@ -0,0 +1,478 @@
|
||||
require 'test_helper'
|
||||
|
||||
class HundredCentes
|
||||
def to_liquid
|
||||
100
|
||||
end
|
||||
end
|
||||
|
||||
class CentsDrop < Liquid::Drop
|
||||
def amount
|
||||
HundredCentes.new
|
||||
end
|
||||
|
||||
def non_zero?
|
||||
true
|
||||
end
|
||||
end
|
||||
|
||||
class ContextSensitiveDrop < Liquid::Drop
|
||||
def test
|
||||
@context['test']
|
||||
end
|
||||
end
|
||||
|
||||
class Category < Liquid::Drop
|
||||
attr_accessor :name
|
||||
|
||||
def initialize(name)
|
||||
@name = name
|
||||
end
|
||||
|
||||
def to_liquid
|
||||
CategoryDrop.new(self)
|
||||
end
|
||||
end
|
||||
|
||||
class CategoryDrop
|
||||
attr_accessor :category, :context
|
||||
def initialize(category)
|
||||
@category = category
|
||||
end
|
||||
end
|
||||
|
||||
class CounterDrop < Liquid::Drop
|
||||
def count
|
||||
@count ||= 0
|
||||
@count += 1
|
||||
end
|
||||
end
|
||||
|
||||
class ArrayLike
|
||||
def fetch(index)
|
||||
end
|
||||
|
||||
def [](index)
|
||||
@counts ||= []
|
||||
@counts[index] ||= 0
|
||||
@counts[index] += 1
|
||||
end
|
||||
|
||||
def to_liquid
|
||||
self
|
||||
end
|
||||
end
|
||||
|
||||
class ContextTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def setup
|
||||
@context = Liquid::Context.new
|
||||
end
|
||||
|
||||
def test_variables
|
||||
@context['string'] = 'string'
|
||||
assert_equal 'string', @context['string']
|
||||
|
||||
@context['num'] = 5
|
||||
assert_equal 5, @context['num']
|
||||
|
||||
@context['time'] = Time.parse('2006-06-06 12:00:00')
|
||||
assert_equal Time.parse('2006-06-06 12:00:00'), @context['time']
|
||||
|
||||
@context['date'] = Date.today
|
||||
assert_equal Date.today, @context['date']
|
||||
|
||||
now = DateTime.now
|
||||
@context['datetime'] = now
|
||||
assert_equal now, @context['datetime']
|
||||
|
||||
@context['bool'] = true
|
||||
assert_equal true, @context['bool']
|
||||
|
||||
@context['bool'] = false
|
||||
assert_equal false, @context['bool']
|
||||
|
||||
@context['nil'] = nil
|
||||
assert_equal nil, @context['nil']
|
||||
assert_equal nil, @context['nil']
|
||||
end
|
||||
|
||||
def test_variables_not_existing
|
||||
assert_equal nil, @context['does_not_exist']
|
||||
end
|
||||
|
||||
def test_scoping
|
||||
assert_nothing_raised do
|
||||
@context.push
|
||||
@context.pop
|
||||
end
|
||||
|
||||
assert_raise(Liquid::ContextError) do
|
||||
@context.pop
|
||||
end
|
||||
|
||||
assert_raise(Liquid::ContextError) do
|
||||
@context.push
|
||||
@context.pop
|
||||
@context.pop
|
||||
end
|
||||
end
|
||||
|
||||
def test_length_query
|
||||
|
||||
@context['numbers'] = [1,2,3,4]
|
||||
|
||||
assert_equal 4, @context['numbers.size']
|
||||
|
||||
@context['numbers'] = {1 => 1,2 => 2,3 => 3,4 => 4}
|
||||
|
||||
assert_equal 4, @context['numbers.size']
|
||||
|
||||
@context['numbers'] = {1 => 1,2 => 2,3 => 3,4 => 4, 'size' => 1000}
|
||||
|
||||
assert_equal 1000, @context['numbers.size']
|
||||
|
||||
end
|
||||
|
||||
def test_hyphenated_variable
|
||||
|
||||
@context['oh-my'] = 'godz'
|
||||
assert_equal 'godz', @context['oh-my']
|
||||
|
||||
end
|
||||
|
||||
def test_add_filter
|
||||
|
||||
filter = Module.new do
|
||||
def hi(output)
|
||||
output + ' hi!'
|
||||
end
|
||||
end
|
||||
|
||||
context = Context.new
|
||||
context.add_filters(filter)
|
||||
assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
|
||||
|
||||
context = Context.new
|
||||
assert_equal 'hi?', context.invoke(:hi, 'hi?')
|
||||
|
||||
context.add_filters(filter)
|
||||
assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
|
||||
|
||||
end
|
||||
|
||||
def test_override_global_filter
|
||||
global = Module.new do
|
||||
def notice(output)
|
||||
"Global #{output}"
|
||||
end
|
||||
end
|
||||
|
||||
local = Module.new do
|
||||
def notice(output)
|
||||
"Local #{output}"
|
||||
end
|
||||
end
|
||||
|
||||
Template.register_filter(global)
|
||||
assert_equal 'Global test', Template.parse("{{'test' | notice }}").render
|
||||
assert_equal 'Local test', Template.parse("{{'test' | notice }}").render({}, :filters => [local])
|
||||
end
|
||||
|
||||
def test_only_intended_filters_make_it_there
|
||||
|
||||
filter = Module.new do
|
||||
def hi(output)
|
||||
output + ' hi!'
|
||||
end
|
||||
end
|
||||
|
||||
context = Context.new
|
||||
methods_before = context.strainer.methods.map { |method| method.to_s }
|
||||
context.add_filters(filter)
|
||||
methods_after = context.strainer.methods.map { |method| method.to_s }
|
||||
assert_equal (methods_before + ["hi"]).sort, methods_after.sort
|
||||
end
|
||||
|
||||
def test_add_item_in_outer_scope
|
||||
@context['test'] = 'test'
|
||||
@context.push
|
||||
assert_equal 'test', @context['test']
|
||||
@context.pop
|
||||
assert_equal 'test', @context['test']
|
||||
end
|
||||
|
||||
def test_add_item_in_inner_scope
|
||||
@context.push
|
||||
@context['test'] = 'test'
|
||||
assert_equal 'test', @context['test']
|
||||
@context.pop
|
||||
assert_equal nil, @context['test']
|
||||
end
|
||||
|
||||
def test_hierachical_data
|
||||
@context['hash'] = {"name" => 'tobi'}
|
||||
assert_equal 'tobi', @context['hash.name']
|
||||
assert_equal 'tobi', @context['hash["name"]']
|
||||
end
|
||||
|
||||
def test_keywords
|
||||
assert_equal true, @context['true']
|
||||
assert_equal false, @context['false']
|
||||
end
|
||||
|
||||
def test_digits
|
||||
assert_equal 100, @context['100']
|
||||
assert_equal 100.00, @context['100.00']
|
||||
end
|
||||
|
||||
def test_strings
|
||||
assert_equal "hello!", @context['"hello!"']
|
||||
assert_equal "hello!", @context["'hello!'"]
|
||||
end
|
||||
|
||||
def test_merge
|
||||
@context.merge({ "test" => "test" })
|
||||
assert_equal 'test', @context['test']
|
||||
@context.merge({ "test" => "newvalue", "foo" => "bar" })
|
||||
assert_equal 'newvalue', @context['test']
|
||||
assert_equal 'bar', @context['foo']
|
||||
end
|
||||
|
||||
def test_array_notation
|
||||
@context['test'] = [1,2,3,4,5]
|
||||
|
||||
assert_equal 1, @context['test[0]']
|
||||
assert_equal 2, @context['test[1]']
|
||||
assert_equal 3, @context['test[2]']
|
||||
assert_equal 4, @context['test[3]']
|
||||
assert_equal 5, @context['test[4]']
|
||||
end
|
||||
|
||||
def test_recoursive_array_notation
|
||||
@context['test'] = {'test' => [1,2,3,4,5]}
|
||||
|
||||
assert_equal 1, @context['test.test[0]']
|
||||
|
||||
@context['test'] = [{'test' => 'worked'}]
|
||||
|
||||
assert_equal 'worked', @context['test[0].test']
|
||||
end
|
||||
|
||||
def test_hash_to_array_transition
|
||||
@context['colors'] = {
|
||||
'Blue' => ['003366','336699', '6699CC', '99CCFF'],
|
||||
'Green' => ['003300','336633', '669966', '99CC99'],
|
||||
'Yellow' => ['CC9900','FFCC00', 'FFFF99', 'FFFFCC'],
|
||||
'Red' => ['660000','993333', 'CC6666', 'FF9999']
|
||||
}
|
||||
|
||||
assert_equal '003366', @context['colors.Blue[0]']
|
||||
assert_equal 'FF9999', @context['colors.Red[3]']
|
||||
end
|
||||
|
||||
def test_try_first
|
||||
@context['test'] = [1,2,3,4,5]
|
||||
|
||||
assert_equal 1, @context['test.first']
|
||||
assert_equal 5, @context['test.last']
|
||||
|
||||
@context['test'] = {'test' => [1,2,3,4,5]}
|
||||
|
||||
assert_equal 1, @context['test.test.first']
|
||||
assert_equal 5, @context['test.test.last']
|
||||
|
||||
@context['test'] = [1]
|
||||
assert_equal 1, @context['test.first']
|
||||
assert_equal 1, @context['test.last']
|
||||
end
|
||||
|
||||
def test_access_hashes_with_hash_notation
|
||||
@context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
|
||||
@context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'} ]}
|
||||
|
||||
assert_equal 5, @context['products["count"]']
|
||||
assert_equal 'deepsnow', @context['products["tags"][0]']
|
||||
assert_equal 'deepsnow', @context['products["tags"].first']
|
||||
assert_equal 'draft151cm', @context['product["variants"][0]["title"]']
|
||||
assert_equal 'element151cm', @context['product["variants"][1]["title"]']
|
||||
assert_equal 'draft151cm', @context['product["variants"][0]["title"]']
|
||||
assert_equal 'element151cm', @context['product["variants"].last["title"]']
|
||||
end
|
||||
|
||||
def test_access_variable_with_hash_notation
|
||||
@context['foo'] = 'baz'
|
||||
@context['bar'] = 'foo'
|
||||
|
||||
assert_equal 'baz', @context['["foo"]']
|
||||
assert_equal 'baz', @context['[bar]']
|
||||
end
|
||||
|
||||
def test_access_hashes_with_hash_access_variables
|
||||
|
||||
@context['var'] = 'tags'
|
||||
@context['nested'] = {'var' => 'tags'}
|
||||
@context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
|
||||
|
||||
assert_equal 'deepsnow', @context['products[var].first']
|
||||
assert_equal 'freestyle', @context['products[nested.var].last']
|
||||
end
|
||||
|
||||
def test_hash_notation_only_for_hash_access
|
||||
@context['array'] = [1,2,3,4,5]
|
||||
@context['hash'] = {'first' => 'Hello'}
|
||||
|
||||
assert_equal 1, @context['array.first']
|
||||
assert_equal nil, @context['array["first"]']
|
||||
assert_equal 'Hello', @context['hash["first"]']
|
||||
end
|
||||
|
||||
def test_first_can_appear_in_middle_of_callchain
|
||||
|
||||
@context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'} ]}
|
||||
|
||||
assert_equal 'draft151cm', @context['product.variants[0].title']
|
||||
assert_equal 'element151cm', @context['product.variants[1].title']
|
||||
assert_equal 'draft151cm', @context['product.variants.first.title']
|
||||
assert_equal 'element151cm', @context['product.variants.last.title']
|
||||
|
||||
end
|
||||
|
||||
def test_cents
|
||||
@context.merge( "cents" => HundredCentes.new )
|
||||
assert_equal 100, @context['cents']
|
||||
end
|
||||
|
||||
def test_nested_cents
|
||||
@context.merge( "cents" => { 'amount' => HundredCentes.new} )
|
||||
assert_equal 100, @context['cents.amount']
|
||||
|
||||
@context.merge( "cents" => { 'cents' => { 'amount' => HundredCentes.new} } )
|
||||
assert_equal 100, @context['cents.cents.amount']
|
||||
end
|
||||
|
||||
def test_cents_through_drop
|
||||
@context.merge( "cents" => CentsDrop.new )
|
||||
assert_equal 100, @context['cents.amount']
|
||||
end
|
||||
|
||||
def test_nested_cents_through_drop
|
||||
@context.merge( "vars" => {"cents" => CentsDrop.new} )
|
||||
assert_equal 100, @context['vars.cents.amount']
|
||||
end
|
||||
|
||||
def test_drop_methods_with_question_marks
|
||||
@context.merge( "cents" => CentsDrop.new )
|
||||
assert @context['cents.non_zero?']
|
||||
end
|
||||
|
||||
def test_context_from_within_drop
|
||||
@context.merge( "test" => '123', "vars" => ContextSensitiveDrop.new )
|
||||
assert_equal '123', @context['vars.test']
|
||||
end
|
||||
|
||||
def test_nested_context_from_within_drop
|
||||
@context.merge( "test" => '123', "vars" => {"local" => ContextSensitiveDrop.new } )
|
||||
assert_equal '123', @context['vars.local.test']
|
||||
end
|
||||
|
||||
def test_ranges
|
||||
@context.merge( "test" => '5' )
|
||||
assert_equal (1..5), @context['(1..5)']
|
||||
assert_equal (1..5), @context['(1..test)']
|
||||
assert_equal (5..5), @context['(test..test)']
|
||||
end
|
||||
|
||||
def test_cents_through_drop_nestedly
|
||||
@context.merge( "cents" => {"cents" => CentsDrop.new} )
|
||||
assert_equal 100, @context['cents.cents.amount']
|
||||
|
||||
@context.merge( "cents" => { "cents" => {"cents" => CentsDrop.new}} )
|
||||
assert_equal 100, @context['cents.cents.cents.amount']
|
||||
end
|
||||
|
||||
def test_drop_with_variable_called_only_once
|
||||
@context['counter'] = CounterDrop.new
|
||||
|
||||
assert_equal 1, @context['counter.count']
|
||||
assert_equal 2, @context['counter.count']
|
||||
assert_equal 3, @context['counter.count']
|
||||
end
|
||||
|
||||
def test_drop_with_key_called_only_once
|
||||
@context['counter'] = CounterDrop.new
|
||||
|
||||
assert_equal 1, @context['counter["count"]']
|
||||
assert_equal 2, @context['counter["count"]']
|
||||
assert_equal 3, @context['counter["count"]']
|
||||
end
|
||||
|
||||
def test_proc_as_variable
|
||||
@context['dynamic'] = Proc.new { 'Hello' }
|
||||
|
||||
assert_equal 'Hello', @context['dynamic']
|
||||
end
|
||||
|
||||
def test_lambda_as_variable
|
||||
@context['dynamic'] = proc { 'Hello' }
|
||||
|
||||
assert_equal 'Hello', @context['dynamic']
|
||||
end
|
||||
|
||||
def test_nested_lambda_as_variable
|
||||
@context['dynamic'] = { "lambda" => proc { 'Hello' } }
|
||||
|
||||
assert_equal 'Hello', @context['dynamic.lambda']
|
||||
end
|
||||
|
||||
def test_array_containing_lambda_as_variable
|
||||
@context['dynamic'] = [1,2, proc { 'Hello' } ,4,5]
|
||||
|
||||
assert_equal 'Hello', @context['dynamic[2]']
|
||||
end
|
||||
|
||||
def test_lambda_is_called_once
|
||||
@context['callcount'] = proc { @global ||= 0; @global += 1; @global.to_s }
|
||||
|
||||
assert_equal '1', @context['callcount']
|
||||
assert_equal '1', @context['callcount']
|
||||
assert_equal '1', @context['callcount']
|
||||
|
||||
@global = nil
|
||||
end
|
||||
|
||||
def test_nested_lambda_is_called_once
|
||||
@context['callcount'] = { "lambda" => proc { @global ||= 0; @global += 1; @global.to_s } }
|
||||
|
||||
assert_equal '1', @context['callcount.lambda']
|
||||
assert_equal '1', @context['callcount.lambda']
|
||||
assert_equal '1', @context['callcount.lambda']
|
||||
|
||||
@global = nil
|
||||
end
|
||||
|
||||
def test_lambda_in_array_is_called_once
|
||||
@context['callcount'] = [1,2, proc { @global ||= 0; @global += 1; @global.to_s } ,4,5]
|
||||
|
||||
assert_equal '1', @context['callcount[2]']
|
||||
assert_equal '1', @context['callcount[2]']
|
||||
assert_equal '1', @context['callcount[2]']
|
||||
|
||||
@global = nil
|
||||
end
|
||||
|
||||
def test_access_to_context_from_proc
|
||||
@context.registers[:magic] = 345392
|
||||
|
||||
@context['magic'] = proc { @context.registers[:magic] }
|
||||
|
||||
assert_equal 345392, @context['magic']
|
||||
end
|
||||
|
||||
def test_to_liquid_and_context_at_first_level
|
||||
@context['category'] = Category.new("foobar")
|
||||
assert_kind_of CategoryDrop, @context['category']
|
||||
assert_equal @context, @context['category'].context
|
||||
end
|
||||
end # ContextTest
|
||||
@@ -0,0 +1,153 @@
|
||||
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 break
|
||||
Breakpoint.breakpoint
|
||||
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
|
||||
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_text_drop
|
||||
output = Liquid::Template.parse( ' {{ product.catchall.unknown }} ' ).render('product' => ProductDrop.new)
|
||||
assert_equal ' method: unknown ', 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
|
||||
end # DropsTest
|
||||
@@ -0,0 +1,69 @@
|
||||
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
|
||||
|
||||
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
|
||||
end # ErrorHandlingTest
|
||||
@@ -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")
|
||||
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
|
||||
@@ -0,0 +1,94 @@
|
||||
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
|
||||
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
|
||||
@@ -0,0 +1,29 @@
|
||||
require 'test_helper'
|
||||
|
||||
class HtmlTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_html_table
|
||||
|
||||
assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
|
||||
'{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
|
||||
'numbers' => [1,2,3,4,5,6])
|
||||
|
||||
assert_template_result("<tr class=\"row1\">\n</tr>\n",
|
||||
'{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
|
||||
'numbers' => [])
|
||||
end
|
||||
|
||||
def test_html_table_with_different_cols
|
||||
assert_template_result("<tr class=\"row1\">\n<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>\n<tr class=\"row2\"><td class=\"col1\"> 6 </td></tr>\n",
|
||||
'{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}',
|
||||
'numbers' => [1,2,3,4,5,6])
|
||||
|
||||
end
|
||||
|
||||
def test_html_col_counter
|
||||
assert_template_result("<tr class=\"row1\">\n<td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row2\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row3\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n",
|
||||
'{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}',
|
||||
'numbers' => [1,2,3,4,5,6])
|
||||
end
|
||||
end # HtmlTagTest
|
||||
@@ -0,0 +1,127 @@
|
||||
require 'test_helper'
|
||||
|
||||
class TestFileSystem
|
||||
def read_template_file(template_path)
|
||||
case template_path
|
||||
when "product"
|
||||
"Product: {{ product.title }} "
|
||||
|
||||
when "locale_variables"
|
||||
"Locale: {{echo1}} {{echo2}}"
|
||||
|
||||
when "variant"
|
||||
"Variant: {{ variant.title }}"
|
||||
|
||||
when "nested_template"
|
||||
"{% include 'header' %} {% include 'body' %} {% include 'footer' %}"
|
||||
|
||||
when "body"
|
||||
"body {% include 'body_detail' %}"
|
||||
|
||||
when "nested_product_template"
|
||||
"Product: {{ nested_product_template.title }} {%include 'details'%} "
|
||||
|
||||
when "recursively_nested_template"
|
||||
"-{% include 'recursively_nested_template' %}"
|
||||
|
||||
when "pick_a_source"
|
||||
"from TestFileSystem"
|
||||
|
||||
else
|
||||
template_path
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class OtherFileSystem
|
||||
def read_template_file(template_path)
|
||||
'from OtherFileSystem'
|
||||
end
|
||||
end
|
||||
|
||||
class IncludeTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def setup
|
||||
Liquid::Template.file_system = TestFileSystem.new
|
||||
end
|
||||
|
||||
def test_include_tag_looks_for_file_system_in_registers_first
|
||||
assert_equal 'from OtherFileSystem',
|
||||
Template.parse("{% include 'pick_a_source' %}").render({}, :registers => {:file_system => OtherFileSystem.new})
|
||||
end
|
||||
|
||||
|
||||
def test_include_tag_with
|
||||
assert_equal "Product: Draft 151cm ",
|
||||
Template.parse("{% include 'product' with products[0] %}").render( "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ] )
|
||||
end
|
||||
|
||||
def test_include_tag_with_default_name
|
||||
assert_equal "Product: Draft 151cm ",
|
||||
Template.parse("{% include 'product' %}").render( "product" => {'title' => 'Draft 151cm'} )
|
||||
end
|
||||
|
||||
def test_include_tag_for
|
||||
|
||||
assert_equal "Product: Draft 151cm Product: Element 155cm ",
|
||||
Template.parse("{% include 'product' for products %}").render( "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ] )
|
||||
end
|
||||
|
||||
def test_include_tag_with_local_variables
|
||||
assert_equal "Locale: test123 ",
|
||||
Template.parse("{% include 'locale_variables' echo1: 'test123' %}").render
|
||||
end
|
||||
|
||||
def test_include_tag_with_multiple_local_variables
|
||||
assert_equal "Locale: test123 test321",
|
||||
Template.parse("{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}").render
|
||||
end
|
||||
|
||||
def test_include_tag_with_multiple_local_variables_from_context
|
||||
assert_equal "Locale: test123 test321",
|
||||
Template.parse("{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}").render('echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'})
|
||||
end
|
||||
|
||||
def test_nested_include_tag
|
||||
assert_equal "body body_detail",
|
||||
Template.parse("{% include 'body' %}").render
|
||||
|
||||
assert_equal "header body body_detail footer",
|
||||
Template.parse("{% include 'nested_template' %}").render
|
||||
end
|
||||
|
||||
def test_nested_include_with_variable
|
||||
|
||||
assert_equal "Product: Draft 151cm details ",
|
||||
Template.parse("{% include 'nested_product_template' with product %}").render("product" => {"title" => 'Draft 151cm'})
|
||||
|
||||
assert_equal "Product: Draft 151cm details Product: Element 155cm details ",
|
||||
Template.parse("{% include 'nested_product_template' for products %}").render("products" => [{"title" => 'Draft 151cm'}, {"title" => 'Element 155cm'}])
|
||||
|
||||
end
|
||||
|
||||
def test_recursively_included_template_does_not_produce_endless_loop
|
||||
|
||||
infinite_file_system = Class.new do
|
||||
def read_template_file(template_path)
|
||||
"-{% include 'loop' %}"
|
||||
end
|
||||
end
|
||||
|
||||
Liquid::Template.file_system = infinite_file_system.new
|
||||
|
||||
assert_raise(Liquid::StackLevelError) do
|
||||
Template.parse("{% include 'loop' %}").render!
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
def test_dynamically_choosen_template
|
||||
|
||||
assert_equal "Test123", Template.parse("{% include template %}").render("template" => 'Test123')
|
||||
assert_equal "Test321", Template.parse("{% include template %}").render("template" => 'Test321')
|
||||
|
||||
assert_equal "Product: Draft 151cm ", Template.parse("{% include template for product %}").render("template" => 'product', 'product' => { 'title' => 'Draft 151cm'})
|
||||
end
|
||||
end # IncludeTagTest
|
||||
@@ -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
|
||||
@@ -0,0 +1,116 @@
|
||||
require 'test_helper'
|
||||
|
||||
module FunnyFilter
|
||||
def make_funny(input)
|
||||
'LOL'
|
||||
end
|
||||
|
||||
def cite_funny(input)
|
||||
"LOL: #{input}"
|
||||
end
|
||||
|
||||
def add_smiley(input, smiley = ":-)")
|
||||
"#{input} #{smiley}"
|
||||
end
|
||||
|
||||
def add_tag(input, tag = "p", id = "foo")
|
||||
%|<#{tag} id="#{id}">#{input}</#{tag}>|
|
||||
end
|
||||
|
||||
def paragraph(input)
|
||||
"<p>#{input}</p>"
|
||||
end
|
||||
|
||||
def link_to(name, url)
|
||||
%|<a href="#{url}">#{name}</a>|
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
class OutputTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def setup
|
||||
@assigns = {
|
||||
'best_cars' => 'bmw',
|
||||
'car' => {'bmw' => 'good', 'gm' => 'bad'}
|
||||
}
|
||||
end
|
||||
|
||||
def test_variable
|
||||
text = %| {{best_cars}} |
|
||||
|
||||
expected = %| bmw |
|
||||
assert_equal expected, Template.parse(text).render(@assigns)
|
||||
end
|
||||
|
||||
def test_variable_traversing
|
||||
text = %| {{car.bmw}} {{car.gm}} {{car.bmw}} |
|
||||
|
||||
expected = %| good bad good |
|
||||
assert_equal expected, Template.parse(text).render(@assigns)
|
||||
end
|
||||
|
||||
def test_variable_piping
|
||||
text = %( {{ car.gm | make_funny }} )
|
||||
expected = %| LOL |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_variable_piping_with_input
|
||||
text = %( {{ car.gm | cite_funny }} )
|
||||
expected = %| LOL: bad |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_variable_piping_with_args
|
||||
text = %! {{ car.gm | add_smiley : ':-(' }} !
|
||||
expected = %| bad :-( |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_variable_piping_with_no_args
|
||||
text = %! {{ car.gm | add_smiley }} !
|
||||
expected = %| bad :-) |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_multiple_variable_piping_with_args
|
||||
text = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
|
||||
expected = %| bad :-( :-( |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_variable_piping_with_args
|
||||
text = %! {{ car.gm | add_tag : 'span', 'bar'}} !
|
||||
expected = %| <span id="bar">bad</span> |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_variable_piping_with_variable_args
|
||||
text = %! {{ car.gm | add_tag : 'span', car.bmw}} !
|
||||
expected = %| <span id="good">bad</span> |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_multiple_pipings
|
||||
text = %( {{ best_cars | cite_funny | paragraph }} )
|
||||
expected = %| <p>LOL: bmw</p> |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
|
||||
def test_link_to
|
||||
text = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
|
||||
expected = %| <a href="http://typo.leetsoft.com">Typo</a> |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
|
||||
end
|
||||
end # OutputTest
|
||||
@@ -0,0 +1,52 @@
|
||||
require 'test_helper'
|
||||
|
||||
class ParsingQuirksTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_error_with_css
|
||||
text = %| div { font-weight: bold; } |
|
||||
template = Template.parse(text)
|
||||
|
||||
assert_equal text, template.render
|
||||
assert_equal [String], template.root.nodelist.collect {|i| i.class}
|
||||
end
|
||||
|
||||
def test_raise_on_single_close_bracet
|
||||
assert_raise(SyntaxError) do
|
||||
Template.parse("text {{method} oh nos!")
|
||||
end
|
||||
end
|
||||
|
||||
def test_raise_on_label_and_no_close_bracets
|
||||
assert_raise(SyntaxError) do
|
||||
Template.parse("TEST {{ ")
|
||||
end
|
||||
end
|
||||
|
||||
def test_raise_on_label_and_no_close_bracets_percent
|
||||
assert_raise(SyntaxError) do
|
||||
Template.parse("TEST {% ")
|
||||
end
|
||||
end
|
||||
|
||||
def test_error_on_empty_filter
|
||||
assert_nothing_raised do
|
||||
Template.parse("{{test |a|b|}}")
|
||||
Template.parse("{{test}}")
|
||||
Template.parse("{{|test|}}")
|
||||
end
|
||||
end
|
||||
|
||||
def test_meaningless_parens
|
||||
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)
|
||||
end
|
||||
|
||||
def test_unexpected_characters_silently_eat_logic
|
||||
markup = "true && false"
|
||||
assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}")
|
||||
markup = "false || true"
|
||||
assert_template_result('',"{% if #{markup} %} YES {% endif %}")
|
||||
end
|
||||
end # ParsingQuirksTest
|
||||
@@ -0,0 +1,44 @@
|
||||
require 'test_helper'
|
||||
|
||||
class RegexpTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_empty
|
||||
assert_equal [], ''.scan(QuotedFragment)
|
||||
end
|
||||
|
||||
def test_quote
|
||||
assert_equal ['"arg 1"'], '"arg 1"'.scan(QuotedFragment)
|
||||
end
|
||||
|
||||
def test_words
|
||||
assert_equal ['arg1', 'arg2'], 'arg1 arg2'.scan(QuotedFragment)
|
||||
end
|
||||
|
||||
def test_tags
|
||||
assert_equal ['<tr>', '</tr>'], '<tr> </tr>'.scan(QuotedFragment)
|
||||
assert_equal ['<tr></tr>'], '<tr></tr>'.scan(QuotedFragment)
|
||||
assert_equal ['<style', 'class="hello">', '</style>'], %|<style class="hello">' </style>|.scan(QuotedFragment)
|
||||
end
|
||||
|
||||
def test_quoted_words
|
||||
assert_equal ['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QuotedFragment)
|
||||
end
|
||||
|
||||
def test_quoted_words
|
||||
assert_equal ['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QuotedFragment)
|
||||
end
|
||||
|
||||
def test_quoted_words_in_the_middle
|
||||
assert_equal ['arg1', 'arg2', '"arg 3"', 'arg4'], 'arg1 arg2 "arg 3" arg4 '.scan(QuotedFragment)
|
||||
end
|
||||
|
||||
def test_variable_parser
|
||||
assert_equal ['var'], 'var'.scan(VariableParser)
|
||||
assert_equal ['var', 'method'], 'var.method'.scan(VariableParser)
|
||||
assert_equal ['var', '[method]'], 'var[method]'.scan(VariableParser)
|
||||
assert_equal ['var', '[method]', '[0]'], 'var[method][0]'.scan(VariableParser)
|
||||
assert_equal ['var', '["method"]', '[0]'], 'var["method"][0]'.scan(VariableParser)
|
||||
assert_equal ['var', '[method]', '[0]', 'method'], 'var[method][0].method'.scan(VariableParser)
|
||||
end
|
||||
end # RegexpTest
|
||||
@@ -0,0 +1,41 @@
|
||||
require 'test_helper'
|
||||
|
||||
module SecurityFilter
|
||||
def add_one(input)
|
||||
"#{input} + 1"
|
||||
end
|
||||
end
|
||||
|
||||
class SecurityTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_no_instance_eval
|
||||
text = %( {{ '1+1' | instance_eval }} )
|
||||
expected = %| 1+1 |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns)
|
||||
end
|
||||
|
||||
def test_no_existing_instance_eval
|
||||
text = %( {{ '1+1' | __instance_eval__ }} )
|
||||
expected = %| 1+1 |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns)
|
||||
end
|
||||
|
||||
|
||||
def test_no_instance_eval_after_mixing_in_new_filter
|
||||
text = %( {{ '1+1' | instance_eval }} )
|
||||
expected = %| 1+1 |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns)
|
||||
end
|
||||
|
||||
|
||||
def test_no_instance_eval_later_in_chain
|
||||
text = %( {{ '1+1' | add_one | instance_eval }} )
|
||||
expected = %| 1+1 + 1 |
|
||||
|
||||
assert_equal expected, Template.parse(text).render(@assigns, :filters => SecurityFilter)
|
||||
end
|
||||
end # SecurityTest
|
||||
@@ -0,0 +1,180 @@
|
||||
require 'test_helper'
|
||||
|
||||
class Filters
|
||||
include Liquid::StandardFilters
|
||||
end
|
||||
|
||||
class StandardFiltersTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def setup
|
||||
@filters = Filters.new
|
||||
end
|
||||
|
||||
def test_size
|
||||
assert_equal 3, @filters.size([1,2,3])
|
||||
assert_equal 0, @filters.size([])
|
||||
assert_equal 0, @filters.size(nil)
|
||||
end
|
||||
|
||||
def test_downcase
|
||||
assert_equal 'testing', @filters.downcase("Testing")
|
||||
assert_equal '', @filters.downcase(nil)
|
||||
end
|
||||
|
||||
def test_upcase
|
||||
assert_equal 'TESTING', @filters.upcase("Testing")
|
||||
assert_equal '', @filters.upcase(nil)
|
||||
end
|
||||
|
||||
def test_upcase
|
||||
assert_equal 'TESTING', @filters.upcase("Testing")
|
||||
assert_equal '', @filters.upcase(nil)
|
||||
end
|
||||
|
||||
def test_truncate
|
||||
assert_equal '1234...', @filters.truncate('1234567890', 7)
|
||||
assert_equal '1234567890', @filters.truncate('1234567890', 20)
|
||||
assert_equal '...', @filters.truncate('1234567890', 0)
|
||||
assert_equal '1234567890', @filters.truncate('1234567890')
|
||||
end
|
||||
|
||||
def test_escape
|
||||
assert_equal '<strong>', @filters.escape('<strong>')
|
||||
assert_equal '<strong>', @filters.h('<strong>')
|
||||
end
|
||||
|
||||
def test_escape_once
|
||||
assert_equal '<strong>', @filters.escape_once(@filters.escape('<strong>'))
|
||||
end
|
||||
|
||||
def test_truncatewords
|
||||
assert_equal 'one two three', @filters.truncatewords('one two three', 4)
|
||||
assert_equal 'one two...', @filters.truncatewords('one two three', 2)
|
||||
assert_equal 'one two three', @filters.truncatewords('one two three')
|
||||
assert_equal 'Two small (13” x 5.5” x 10” high) baskets fit inside one large basket (13”...', @filters.truncatewords('Two small (13” x 5.5” x 10” high) baskets fit inside one large basket (13” x 16” x 10.5” high) with cover.', 15)
|
||||
end
|
||||
|
||||
def test_strip_html
|
||||
assert_equal 'test', @filters.strip_html("<div>test</div>")
|
||||
assert_equal 'test', @filters.strip_html("<div id='test'>test</div>")
|
||||
assert_equal '', @filters.strip_html("<script type='text/javascript'>document.write('some stuff');</script>")
|
||||
assert_equal '', @filters.strip_html(nil)
|
||||
end
|
||||
|
||||
def test_join
|
||||
assert_equal '1 2 3 4', @filters.join([1,2,3,4])
|
||||
assert_equal '1 - 2 - 3 - 4', @filters.join([1,2,3,4], ' - ')
|
||||
end
|
||||
|
||||
def test_sort
|
||||
assert_equal [1,2,3,4], @filters.sort([4,3,2,1])
|
||||
assert_equal [{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], @filters.sort([{"a" => 4}, {"a" => 3}, {"a" => 1}, {"a" => 2}], "a")
|
||||
end
|
||||
|
||||
def test_map
|
||||
assert_equal [1,2,3,4], @filters.map([{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], 'a')
|
||||
assert_template_result 'abc', "{{ ary | map:'foo' | map:'bar' }}",
|
||||
'ary' => [{'foo' => {'bar' => 'a'}}, {'foo' => {'bar' => 'b'}}, {'foo' => {'bar' => 'c'}}]
|
||||
end
|
||||
|
||||
def test_date
|
||||
assert_equal 'May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B")
|
||||
assert_equal 'June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B")
|
||||
assert_equal 'July', @filters.date(Time.parse("2006-07-05 10:00:00"), "%B")
|
||||
|
||||
assert_equal 'May', @filters.date("2006-05-05 10:00:00", "%B")
|
||||
assert_equal 'June', @filters.date("2006-06-05 10:00:00", "%B")
|
||||
assert_equal 'July', @filters.date("2006-07-05 10:00:00", "%B")
|
||||
|
||||
assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
|
||||
assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
|
||||
assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
|
||||
assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", nil)
|
||||
|
||||
assert_equal '07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y")
|
||||
|
||||
assert_equal "07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y")
|
||||
|
||||
assert_equal nil, @filters.date(nil, "%B")
|
||||
end
|
||||
|
||||
|
||||
def test_first_last
|
||||
assert_equal 1, @filters.first([1,2,3])
|
||||
assert_equal 3, @filters.last([1,2,3])
|
||||
assert_equal nil, @filters.first([])
|
||||
assert_equal nil, @filters.last([])
|
||||
end
|
||||
|
||||
def test_replace
|
||||
assert_equal 'b b b b', @filters.replace("a a a a", 'a', 'b')
|
||||
assert_equal 'b a a a', @filters.replace_first("a a a a", 'a', 'b')
|
||||
assert_template_result 'b a a a', "{{ 'a a a a' | replace_first: 'a', 'b' }}"
|
||||
end
|
||||
|
||||
def test_remove
|
||||
assert_equal ' ', @filters.remove("a a a a", 'a')
|
||||
assert_equal 'a a a', @filters.remove_first("a a a a", 'a ')
|
||||
assert_template_result 'a a a', "{{ 'a a a a' | remove_first: 'a ' }}"
|
||||
end
|
||||
|
||||
def test_pipes_in_string_arguments
|
||||
assert_template_result 'foobar', "{{ 'foo|bar' | remove: '|' }}"
|
||||
end
|
||||
|
||||
def test_strip_newlines
|
||||
assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc"
|
||||
end
|
||||
|
||||
def test_newlines_to_br
|
||||
assert_template_result "a<br />\nb<br />\nc", "{{ source | newline_to_br }}", 'source' => "a\nb\nc"
|
||||
end
|
||||
|
||||
def test_plus
|
||||
assert_template_result "2", "{{ 1 | plus:1 }}"
|
||||
assert_template_result "2.0", "{{ '1' | plus:'1.0' }}"
|
||||
end
|
||||
|
||||
def test_minus
|
||||
assert_template_result "4", "{{ input | minus:operand }}", 'input' => 5, 'operand' => 1
|
||||
assert_template_result "2.3", "{{ '4.3' | minus:'2' }}"
|
||||
end
|
||||
|
||||
def test_times
|
||||
assert_template_result "12", "{{ 3 | times:4 }}"
|
||||
assert_template_result "0", "{{ 'foo' | times:4 }}"
|
||||
|
||||
# Ruby v1.9.2-rc1, or higher, backwards compatible Float test
|
||||
assert_match(/(6\.3)|(6\.(0{13})1)/, Template.parse("{{ '2.1' | times:3 }}").render)
|
||||
|
||||
assert_template_result "6", "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}"
|
||||
end
|
||||
|
||||
def test_divided_by
|
||||
assert_template_result "4", "{{ 12 | divided_by:3 }}"
|
||||
assert_template_result "4", "{{ 14 | divided_by:3 }}"
|
||||
|
||||
# Ruby v1.9.2-rc1, or higher, backwards compatible Float test
|
||||
assert_match(/4\.(6{13,14})7/, Template.parse("{{ 14 | divided_by:'3.0' }}").render)
|
||||
|
||||
assert_template_result "5", "{{ 15 | divided_by:3 }}"
|
||||
assert_template_result "Liquid error: divided by 0", "{{ 5 | divided_by:0 }}"
|
||||
end
|
||||
|
||||
def test_append
|
||||
assigns = {'a' => 'bc', 'b' => 'd' }
|
||||
assert_template_result('bcd',"{{ a | append: 'd'}}",assigns)
|
||||
assert_template_result('bcd',"{{ a | append: b}}",assigns)
|
||||
end
|
||||
|
||||
def test_prepend
|
||||
assigns = {'a' => 'bc', 'b' => 'a' }
|
||||
assert_template_result('abc',"{{ a | prepend: 'a'}}",assigns)
|
||||
assert_template_result('abc',"{{ a | prepend: b}}",assigns)
|
||||
end
|
||||
|
||||
def test_cannot_access_private_methods
|
||||
assert_template_result('a',"{{ 'a' | to_number }}")
|
||||
end
|
||||
end # StandardFiltersTest
|
||||
@@ -0,0 +1,25 @@
|
||||
require 'test_helper'
|
||||
|
||||
class StrainerTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_strainer
|
||||
strainer = Strainer.create(nil)
|
||||
assert_equal false, strainer.respond_to?('__test__')
|
||||
assert_equal false, strainer.respond_to?('test')
|
||||
assert_equal false, strainer.respond_to?('instance_eval')
|
||||
assert_equal false, strainer.respond_to?('__send__')
|
||||
assert_equal true, strainer.respond_to?('size') # from the standard lib
|
||||
end
|
||||
|
||||
def test_should_respond_to_two_parameters
|
||||
strainer = Strainer.create(nil)
|
||||
assert_equal true, strainer.respond_to?('size', false)
|
||||
end
|
||||
|
||||
# Asserts that Object#respond_to_missing? is not being undefined in Ruby versions where it has been implemented
|
||||
# Currently this method is only present in Ruby v1.9.2, or higher
|
||||
def test_object_respond_to_missing
|
||||
assert_equal Object.respond_to?(:respond_to_missing?), Strainer.create(nil).respond_to?(:respond_to_missing?)
|
||||
end
|
||||
end # StrainerTest
|
||||
@@ -0,0 +1,153 @@
|
||||
require 'test_helper'
|
||||
|
||||
class IfElseTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_if
|
||||
assert_template_result(' ',' {% if false %} this text should not go into the output {% endif %} ')
|
||||
assert_template_result(' this text should go into the output ',
|
||||
' {% if true %} this text should go into the output {% endif %} ')
|
||||
assert_template_result(' you rock ?','{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?')
|
||||
end
|
||||
|
||||
def test_if_else
|
||||
assert_template_result(' YES ','{% if false %} NO {% else %} YES {% endif %}')
|
||||
assert_template_result(' YES ','{% if true %} YES {% else %} NO {% endif %}')
|
||||
assert_template_result(' YES ','{% if "foo" %} YES {% else %} NO {% endif %}')
|
||||
end
|
||||
|
||||
def test_if_boolean
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => true)
|
||||
end
|
||||
|
||||
def test_if_or
|
||||
assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => false)
|
||||
assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => false, 'b' => true)
|
||||
assert_template_result('', '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => false)
|
||||
|
||||
assert_template_result(' YES ','{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => true)
|
||||
assert_template_result('', '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => false)
|
||||
end
|
||||
|
||||
def test_if_or_with_operators
|
||||
assert_template_result(' YES ','{% if a == true or b == true %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
assert_template_result(' YES ','{% if a == true or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
assert_template_result('','{% if a == false or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
|
||||
end
|
||||
|
||||
def test_comparison_of_strings_containing_and_or_or
|
||||
assert_nothing_raised do
|
||||
awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
|
||||
assigns = {'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true}
|
||||
assert_template_result(' YES ',"{% if #{awful_markup} %} YES {% endif %}", assigns)
|
||||
end
|
||||
end
|
||||
|
||||
def test_comparison_of_expressions_starting_with_and_or_or
|
||||
assigns = {'order' => {'items_count' => 0}, 'android' => {'name' => 'Roy'}}
|
||||
assert_nothing_raised do
|
||||
assert_template_result( "YES",
|
||||
"{% if android.name == 'Roy' %}YES{% endif %}",
|
||||
assigns)
|
||||
end
|
||||
assert_nothing_raised do
|
||||
assert_template_result( "YES",
|
||||
"{% if order.items_count == 0 %}YES{% endif %}",
|
||||
assigns)
|
||||
end
|
||||
end
|
||||
|
||||
def test_if_and
|
||||
assert_template_result(' YES ','{% if true and true %} YES {% endif %}')
|
||||
assert_template_result('','{% if false and true %} YES {% endif %}')
|
||||
assert_template_result('','{% if false and true %} YES {% endif %}')
|
||||
end
|
||||
|
||||
|
||||
def test_hash_miss_generates_false
|
||||
assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {})
|
||||
end
|
||||
|
||||
def test_if_from_variable
|
||||
assert_template_result('','{% if var %} NO {% endif %}', 'var' => false)
|
||||
assert_template_result('','{% if var %} NO {% endif %}', 'var' => nil)
|
||||
assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {'bar' => false})
|
||||
assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {})
|
||||
assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => nil)
|
||||
assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => true)
|
||||
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => "text")
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => true)
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => 1)
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => {})
|
||||
assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => [])
|
||||
assert_template_result(' YES ','{% if "foo" %} YES {% endif %}')
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => true})
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => "text"})
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => 1 })
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => {} })
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => [] })
|
||||
|
||||
assert_template_result(' YES ','{% if var %} NO {% else %} YES {% endif %}', 'var' => false)
|
||||
assert_template_result(' YES ','{% if var %} NO {% else %} YES {% endif %}', 'var' => nil)
|
||||
assert_template_result(' YES ','{% if var %} YES {% else %} NO {% endif %}', 'var' => true)
|
||||
assert_template_result(' YES ','{% if "foo" %} YES {% else %} NO {% endif %}', 'var' => "text")
|
||||
|
||||
assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {'bar' => false})
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => {'bar' => true})
|
||||
assert_template_result(' YES ','{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => {'bar' => "text"})
|
||||
assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {'notbar' => true})
|
||||
assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {})
|
||||
assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'notfoo' => {'bar' => true})
|
||||
end
|
||||
|
||||
def test_nested_if
|
||||
assert_template_result('', '{% if false %}{% if false %} NO {% endif %}{% endif %}')
|
||||
assert_template_result('', '{% if false %}{% if true %} NO {% endif %}{% endif %}')
|
||||
assert_template_result('', '{% if true %}{% if false %} NO {% endif %}{% endif %}')
|
||||
assert_template_result(' YES ', '{% if true %}{% if true %} YES {% endif %}{% endif %}')
|
||||
|
||||
assert_template_result(' YES ', '{% if true %}{% if true %} YES {% else %} NO {% endif %}{% else %} NO {% endif %}')
|
||||
assert_template_result(' YES ', '{% if true %}{% if false %} NO {% else %} YES {% endif %}{% else %} NO {% endif %}')
|
||||
assert_template_result(' YES ', '{% if false %}{% if true %} NO {% else %} NONO {% endif %}{% else %} YES {% endif %}')
|
||||
|
||||
end
|
||||
|
||||
def test_comparisons_on_null
|
||||
assert_template_result('','{% if null < 10 %} NO {% endif %}')
|
||||
assert_template_result('','{% if null <= 10 %} NO {% endif %}')
|
||||
assert_template_result('','{% if null >= 10 %} NO {% endif %}')
|
||||
assert_template_result('','{% if null > 10 %} NO {% endif %}')
|
||||
|
||||
assert_template_result('','{% if 10 < null %} NO {% endif %}')
|
||||
assert_template_result('','{% if 10 <= null %} NO {% endif %}')
|
||||
assert_template_result('','{% if 10 >= null %} NO {% endif %}')
|
||||
assert_template_result('','{% if 10 > null %} NO {% endif %}')
|
||||
end
|
||||
|
||||
def test_else_if
|
||||
assert_template_result('0','{% if 0 == 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
|
||||
assert_template_result('1','{% if 0 != 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
|
||||
assert_template_result('2','{% if 0 != 0 %}0{% elsif 1 != 1%}1{% else %}2{% endif %}')
|
||||
|
||||
assert_template_result('elsif','{% if false %}if{% elsif true %}elsif{% endif %}')
|
||||
end
|
||||
|
||||
def test_syntax_error_no_variable
|
||||
assert_raise(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}')}
|
||||
end
|
||||
|
||||
def test_syntax_error_no_expression
|
||||
assert_raise(SyntaxError) { assert_template_result('', '{% if %}') }
|
||||
end
|
||||
|
||||
def test_if_with_custom_condition
|
||||
Condition.operators['contains'] = :[]
|
||||
|
||||
assert_template_result('yes', %({% if 'bob' contains 'o' %}yes{% endif %}))
|
||||
assert_template_result('no', %({% if 'bob' contains 'f' %}yes{% else %}no{% endif %}))
|
||||
ensure
|
||||
Condition.operators.delete 'contains'
|
||||
end
|
||||
end # IfElseTest
|
||||
@@ -0,0 +1,455 @@
|
||||
require 'test_helper'
|
||||
|
||||
class StandardTagTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_tag
|
||||
tag = Tag.new('tag', [], [])
|
||||
assert_equal 'liquid::tag', tag.name
|
||||
assert_equal '', tag.render(Context.new)
|
||||
end
|
||||
|
||||
def test_no_transform
|
||||
assert_template_result('this text should come out of the template without change...',
|
||||
'this text should come out of the template without change...')
|
||||
|
||||
assert_template_result('blah','blah')
|
||||
assert_template_result('<blah>','<blah>')
|
||||
assert_template_result('|,.:','|,.:')
|
||||
assert_template_result('','')
|
||||
|
||||
text = %|this shouldnt see any transformation either but has multiple lines
|
||||
as you can clearly see here ...|
|
||||
assert_template_result(text,text)
|
||||
end
|
||||
|
||||
def test_has_a_block_which_does_nothing
|
||||
assert_template_result(%|the comment block should be removed .. right?|,
|
||||
%|the comment block should be removed {%comment%} be gone.. {%endcomment%} .. right?|)
|
||||
|
||||
assert_template_result('','{%comment%}{%endcomment%}')
|
||||
assert_template_result('','{%comment%}{% endcomment %}')
|
||||
assert_template_result('','{% comment %}{%endcomment%}')
|
||||
assert_template_result('','{% comment %}{% endcomment %}')
|
||||
assert_template_result('','{%comment%}comment{%endcomment%}')
|
||||
assert_template_result('','{% comment %}comment{% endcomment %}')
|
||||
|
||||
assert_template_result('foobar','foo{%comment%}comment{%endcomment%}bar')
|
||||
assert_template_result('foobar','foo{% comment %}comment{% endcomment %}bar')
|
||||
assert_template_result('foobar','foo{%comment%} comment {%endcomment%}bar')
|
||||
assert_template_result('foobar','foo{% comment %} comment {% endcomment %}bar')
|
||||
|
||||
assert_template_result('foo bar','foo {%comment%} {%endcomment%} bar')
|
||||
assert_template_result('foo bar','foo {%comment%}comment{%endcomment%} bar')
|
||||
assert_template_result('foo bar','foo {%comment%} comment {%endcomment%} bar')
|
||||
|
||||
assert_template_result('foobar','foo{%comment%}
|
||||
{%endcomment%}bar')
|
||||
end
|
||||
|
||||
def test_for
|
||||
assert_template_result(' yo yo yo yo ','{%for item in array%} yo {%endfor%}','array' => [1,2,3,4])
|
||||
assert_template_result('yoyo','{%for item in array%}yo{%endfor%}','array' => [1,2])
|
||||
assert_template_result(' yo ','{%for item in array%} yo {%endfor%}','array' => [1])
|
||||
assert_template_result('','{%for item in array%}{%endfor%}','array' => [1,2])
|
||||
expected = <<HERE
|
||||
|
||||
yo
|
||||
|
||||
yo
|
||||
|
||||
yo
|
||||
|
||||
HERE
|
||||
template = <<HERE
|
||||
{%for item in array%}
|
||||
yo
|
||||
{%endfor%}
|
||||
HERE
|
||||
assert_template_result(expected,template,'array' => [1,2,3])
|
||||
end
|
||||
|
||||
def test_for_with_range
|
||||
assert_template_result(' 1 2 3 ','{%for item in (1..3) %} {{item}} {%endfor%}')
|
||||
end
|
||||
|
||||
def test_for_with_variable
|
||||
assert_template_result(' 1 2 3 ','{%for item in array%} {{item}} {%endfor%}','array' => [1,2,3])
|
||||
assert_template_result('123','{%for item in array%}{{item}}{%endfor%}','array' => [1,2,3])
|
||||
assert_template_result('123','{% for item in array %}{{item}}{% endfor %}','array' => [1,2,3])
|
||||
assert_template_result('abcd','{%for item in array%}{{item}}{%endfor%}','array' => ['a','b','c','d'])
|
||||
assert_template_result('a b c','{%for item in array%}{{item}}{%endfor%}','array' => ['a',' ','b',' ','c'])
|
||||
assert_template_result('abc','{%for item in array%}{{item}}{%endfor%}','array' => ['a','','b','','c'])
|
||||
end
|
||||
|
||||
def test_for_helpers
|
||||
assigns = {'array' => [1,2,3] }
|
||||
assert_template_result(' 1/3 2/3 3/3 ',
|
||||
'{%for item in array%} {{forloop.index}}/{{forloop.length}} {%endfor%}',
|
||||
assigns)
|
||||
assert_template_result(' 1 2 3 ', '{%for item in array%} {{forloop.index}} {%endfor%}', assigns)
|
||||
assert_template_result(' 0 1 2 ', '{%for item in array%} {{forloop.index0}} {%endfor%}', assigns)
|
||||
assert_template_result(' 2 1 0 ', '{%for item in array%} {{forloop.rindex0}} {%endfor%}', assigns)
|
||||
assert_template_result(' 3 2 1 ', '{%for item in array%} {{forloop.rindex}} {%endfor%}', assigns)
|
||||
assert_template_result(' true false false ', '{%for item in array%} {{forloop.first}} {%endfor%}', assigns)
|
||||
assert_template_result(' false false true ', '{%for item in array%} {{forloop.last}} {%endfor%}', assigns)
|
||||
end
|
||||
|
||||
def test_for_and_if
|
||||
assigns = {'array' => [1,2,3] }
|
||||
assert_template_result('+--',
|
||||
'{%for item in array%}{% if forloop.first %}+{% else %}-{% endif %}{%endfor%}',
|
||||
assigns)
|
||||
end
|
||||
|
||||
def test_limiting
|
||||
assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
|
||||
assert_template_result('12', '{%for i in array limit:2 %}{{ i }}{%endfor%}', assigns)
|
||||
assert_template_result('1234', '{%for i in array limit:4 %}{{ i }}{%endfor%}', assigns)
|
||||
assert_template_result('3456', '{%for i in array limit:4 offset:2 %}{{ i }}{%endfor%}', assigns)
|
||||
assert_template_result('3456', '{%for i in array limit: 4 offset: 2 %}{{ i }}{%endfor%}', assigns)
|
||||
end
|
||||
|
||||
def test_dynamic_variable_limiting
|
||||
assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
|
||||
assigns['limit'] = 2
|
||||
assigns['offset'] = 2
|
||||
|
||||
assert_template_result('34', '{%for i in array limit: limit offset: offset %}{{ i }}{%endfor%}', assigns)
|
||||
end
|
||||
|
||||
def test_nested_for
|
||||
assigns = {'array' => [[1,2],[3,4],[5,6]] }
|
||||
assert_template_result('123456', '{%for item in array%}{%for i in item%}{{ i }}{%endfor%}{%endfor%}', assigns)
|
||||
end
|
||||
|
||||
def test_offset_only
|
||||
assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
|
||||
assert_template_result('890', '{%for i in array offset:7 %}{{ i }}{%endfor%}', assigns)
|
||||
end
|
||||
|
||||
def test_pause_resume
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
|
||||
markup = <<-MKUP
|
||||
{%for i in array.items limit: 3 %}{{i}}{%endfor%}
|
||||
next
|
||||
{%for i in array.items offset:continue limit: 3 %}{{i}}{%endfor%}
|
||||
next
|
||||
{%for i in array.items offset:continue limit: 3 %}{{i}}{%endfor%}
|
||||
MKUP
|
||||
expected = <<-XPCTD
|
||||
123
|
||||
next
|
||||
456
|
||||
next
|
||||
789
|
||||
XPCTD
|
||||
assert_template_result(expected,markup,assigns)
|
||||
end
|
||||
|
||||
def test_pause_resume_limit
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
|
||||
markup = <<-MKUP
|
||||
{%for i in array.items limit:3 %}{{i}}{%endfor%}
|
||||
next
|
||||
{%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%}
|
||||
next
|
||||
{%for i in array.items offset:continue limit:1 %}{{i}}{%endfor%}
|
||||
MKUP
|
||||
expected = <<-XPCTD
|
||||
123
|
||||
next
|
||||
456
|
||||
next
|
||||
7
|
||||
XPCTD
|
||||
assert_template_result(expected,markup,assigns)
|
||||
end
|
||||
|
||||
def test_pause_resume_BIG_limit
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
|
||||
markup = <<-MKUP
|
||||
{%for i in array.items limit:3 %}{{i}}{%endfor%}
|
||||
next
|
||||
{%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%}
|
||||
next
|
||||
{%for i in array.items offset:continue limit:1000 %}{{i}}{%endfor%}
|
||||
MKUP
|
||||
expected = <<-XPCTD
|
||||
123
|
||||
next
|
||||
456
|
||||
next
|
||||
7890
|
||||
XPCTD
|
||||
assert_template_result(expected,markup,assigns)
|
||||
end
|
||||
|
||||
|
||||
def test_pause_resume_BIG_offset
|
||||
assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
|
||||
markup = %q({%for i in array.items limit:3 %}{{i}}{%endfor%}
|
||||
next
|
||||
{%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%}
|
||||
next
|
||||
{%for i in array.items offset:continue limit:3 offset:1000 %}{{i}}{%endfor%})
|
||||
expected = %q(123
|
||||
next
|
||||
456
|
||||
next
|
||||
)
|
||||
assert_template_result(expected,markup,assigns)
|
||||
end
|
||||
|
||||
def test_assign
|
||||
assigns = {'var' => 'content' }
|
||||
assert_template_result('var2: var2:content', 'var2:{{var2}} {%assign var2 = var%} var2:{{var2}}', assigns)
|
||||
|
||||
end
|
||||
|
||||
def test_hyphenated_assign
|
||||
assigns = {'a-b' => '1' }
|
||||
assert_template_result('a-b:1 a-b:2', 'a-b:{{a-b}} {%assign a-b = 2 %}a-b:{{a-b}}', assigns)
|
||||
|
||||
end
|
||||
|
||||
def test_assign_with_colon_and_spaces
|
||||
assigns = {'var' => {'a:b c' => {'paged' => '1' }}}
|
||||
assert_template_result('var2: 1', '{%assign var2 = var["a:b c"].paged %}var2: {{var2}}', assigns)
|
||||
end
|
||||
|
||||
def test_capture
|
||||
assigns = {'var' => 'content' }
|
||||
assert_template_result('content foo content foo ',
|
||||
'{{ var2 }}{% capture var2 %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
|
||||
assigns)
|
||||
end
|
||||
|
||||
def test_capture_detects_bad_syntax
|
||||
assert_raise(SyntaxError) do
|
||||
assert_template_result('content foo content foo ',
|
||||
'{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
|
||||
{'var' => 'content' })
|
||||
end
|
||||
end
|
||||
|
||||
def test_case
|
||||
assigns = {'condition' => 2 }
|
||||
assert_template_result(' its 2 ',
|
||||
'{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = {'condition' => 1 }
|
||||
assert_template_result(' its 1 ',
|
||||
'{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = {'condition' => 3 }
|
||||
assert_template_result('',
|
||||
'{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = {'condition' => "string here" }
|
||||
assert_template_result(' hit ',
|
||||
'{% case condition %}{% when "string here" %} hit {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = {'condition' => "bad string here" }
|
||||
assert_template_result('',
|
||||
'{% case condition %}{% when "string here" %} hit {% endcase %}',\
|
||||
assigns)
|
||||
end
|
||||
|
||||
def test_case_with_else
|
||||
assigns = {'condition' => 5 }
|
||||
assert_template_result(' hit ',
|
||||
'{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = {'condition' => 6 }
|
||||
assert_template_result(' else ',
|
||||
'{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
|
||||
assigns)
|
||||
|
||||
assigns = {'condition' => 6 }
|
||||
assert_template_result(' else ',
|
||||
'{% case condition %} {% when 5 %} hit {% else %} else {% endcase %}',
|
||||
assigns)
|
||||
end
|
||||
|
||||
def test_case_on_size
|
||||
assert_template_result('', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [])
|
||||
assert_template_result('1', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1])
|
||||
assert_template_result('2', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1])
|
||||
assert_template_result('', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1])
|
||||
assert_template_result('', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1, 1])
|
||||
assert_template_result('', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1, 1, 1])
|
||||
end
|
||||
|
||||
def test_case_on_size_with_else
|
||||
assert_template_result('else',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [])
|
||||
|
||||
assert_template_result('1',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1])
|
||||
|
||||
assert_template_result('2',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1])
|
||||
|
||||
assert_template_result('else',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1, 1])
|
||||
|
||||
assert_template_result('else',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1, 1, 1])
|
||||
|
||||
assert_template_result('else',
|
||||
'{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
|
||||
'a' => [1, 1, 1, 1, 1])
|
||||
end
|
||||
|
||||
def test_case_on_length_with_else
|
||||
assert_template_result('else',
|
||||
'{% case a.empty? %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
|
||||
assert_template_result('false',
|
||||
'{% case false %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
|
||||
assert_template_result('true',
|
||||
'{% case true %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
|
||||
assert_template_result('else',
|
||||
'{% case NULL %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
|
||||
{})
|
||||
end
|
||||
|
||||
def test_assign_from_case
|
||||
# Example from the shopify forums
|
||||
code = %q({% case collection.handle %}{% when 'menswear-jackets' %}{% assign ptitle = 'menswear' %}{% when 'menswear-t-shirts' %}{% assign ptitle = 'menswear' %}{% else %}{% assign ptitle = 'womenswear' %}{% endcase %}{{ ptitle }})
|
||||
template = Liquid::Template.parse(code)
|
||||
assert_equal "menswear", template.render("collection" => {'handle' => 'menswear-jackets'})
|
||||
assert_equal "menswear", template.render("collection" => {'handle' => 'menswear-t-shirts'})
|
||||
assert_equal "womenswear", template.render("collection" => {'handle' => 'x'})
|
||||
assert_equal "womenswear", template.render("collection" => {'handle' => 'y'})
|
||||
assert_equal "womenswear", template.render("collection" => {'handle' => 'z'})
|
||||
end
|
||||
|
||||
def test_case_when_or
|
||||
code = '{% case condition %}{% when 1 or 2 or 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 2 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 3 })
|
||||
assert_template_result(' its 4 ', code, {'condition' => 4 })
|
||||
assert_template_result('', code, {'condition' => 5 })
|
||||
|
||||
code = '{% case condition %}{% when 1 or "string" or null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 'string' })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => nil })
|
||||
assert_template_result('', code, {'condition' => 'something else' })
|
||||
end
|
||||
|
||||
def test_case_when_comma
|
||||
code = '{% case condition %}{% when 1, 2, 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 2 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 3 })
|
||||
assert_template_result(' its 4 ', code, {'condition' => 4 })
|
||||
assert_template_result('', code, {'condition' => 5 })
|
||||
|
||||
code = '{% case condition %}{% when 1, "string", null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 'string' })
|
||||
assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => nil })
|
||||
assert_template_result('', code, {'condition' => 'something else' })
|
||||
end
|
||||
|
||||
def test_assign
|
||||
assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{{a}}' ).render
|
||||
end
|
||||
|
||||
def test_assign_an_empty_string
|
||||
assert_equal '', Liquid::Template.parse( '{% assign a = ""%}{{a}}' ).render
|
||||
end
|
||||
|
||||
def test_assign_is_global
|
||||
assert_equal 'variable',
|
||||
Liquid::Template.parse( '{%for i in (1..2) %}{% assign a = "variable"%}{% endfor %}{{a}}' ).render
|
||||
end
|
||||
|
||||
def test_case_detects_bad_syntax
|
||||
assert_raise(SyntaxError) do
|
||||
assert_template_result('', '{% case false %}{% when %}true{% endcase %}', {})
|
||||
end
|
||||
|
||||
assert_raise(SyntaxError) do
|
||||
assert_template_result('', '{% case false %}{% huh %}true{% endcase %}', {})
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
def test_cycle
|
||||
assert_template_result('one','{%cycle "one", "two"%}')
|
||||
assert_template_result('one two','{%cycle "one", "two"%} {%cycle "one", "two"%}')
|
||||
assert_template_result(' two','{%cycle "", "two"%} {%cycle "", "two"%}')
|
||||
|
||||
assert_template_result('one two one','{%cycle "one", "two"%} {%cycle "one", "two"%} {%cycle "one", "two"%}')
|
||||
|
||||
assert_template_result('text-align: left text-align: right',
|
||||
'{%cycle "text-align: left", "text-align: right" %} {%cycle "text-align: left", "text-align: right"%}')
|
||||
end
|
||||
|
||||
def test_multiple_cycles
|
||||
assert_template_result('1 2 1 1 2 3 1',
|
||||
'{%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%}')
|
||||
end
|
||||
|
||||
def test_multiple_named_cycles
|
||||
assert_template_result('one one two two one one',
|
||||
'{%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %}')
|
||||
end
|
||||
|
||||
def test_multiple_named_cycles_with_names_from_context
|
||||
assigns = {"var1" => 1, "var2" => 2 }
|
||||
assert_template_result('one one two two one one',
|
||||
'{%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %}', assigns)
|
||||
end
|
||||
|
||||
def test_size_of_array
|
||||
assigns = {"array" => [1,2,3,4]}
|
||||
assert_template_result('array has 4 elements', "array has {{ array.size }} elements", assigns)
|
||||
end
|
||||
|
||||
def test_size_of_hash
|
||||
assigns = {"hash" => {:a => 1, :b => 2, :c=> 3, :d => 4}}
|
||||
assert_template_result('hash has 4 elements', "hash has {{ hash.size }} elements", assigns)
|
||||
end
|
||||
|
||||
def test_illegal_symbols
|
||||
assert_template_result('', '{% if true == empty %}?{% endif %}', {})
|
||||
assert_template_result('', '{% if true == null %}?{% endif %}', {})
|
||||
assert_template_result('', '{% if empty == true %}?{% endif %}', {})
|
||||
assert_template_result('', '{% if null == true %}?{% endif %}', {})
|
||||
end
|
||||
|
||||
def test_for_reversed
|
||||
assigns = {'array' => [ 1, 2, 3] }
|
||||
assert_template_result('321','{%for item in array reversed %}{{item}}{%endfor%}',assigns)
|
||||
end
|
||||
|
||||
|
||||
def test_ifchanged
|
||||
assigns = {'array' => [ 1, 1, 2, 2, 3, 3] }
|
||||
assert_template_result('123','{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}',assigns)
|
||||
|
||||
assigns = {'array' => [ 1, 1, 1, 1] }
|
||||
assert_template_result('1','{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}',assigns)
|
||||
end
|
||||
end # StandardTagTest
|
||||
@@ -0,0 +1,134 @@
|
||||
require 'test_helper'
|
||||
|
||||
class StatementsTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_true_eql_true
|
||||
text = %| {% if true == true %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render
|
||||
end
|
||||
|
||||
def test_true_not_eql_true
|
||||
text = %| {% if true != true %} true {% else %} false {% endif %} |
|
||||
expected = %| false |
|
||||
assert_equal expected, Template.parse(text).render
|
||||
end
|
||||
|
||||
def test_true_lq_true
|
||||
text = %| {% if 0 > 0 %} true {% else %} false {% endif %} |
|
||||
expected = %| false |
|
||||
assert_equal expected, Template.parse(text).render
|
||||
end
|
||||
|
||||
def test_one_lq_zero
|
||||
text = %| {% if 1 > 0 %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render
|
||||
end
|
||||
|
||||
def test_zero_lq_one
|
||||
text = %| {% if 0 < 1 %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render
|
||||
end
|
||||
|
||||
def test_zero_lq_or_equal_one
|
||||
text = %| {% if 0 <= 0 %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render
|
||||
end
|
||||
|
||||
def test_zero_lq_or_equal_one_involving_nil
|
||||
text = %| {% if null <= 0 %} true {% else %} false {% endif %} |
|
||||
expected = %| false |
|
||||
assert_equal expected, Template.parse(text).render
|
||||
|
||||
|
||||
text = %| {% if 0 <= null %} true {% else %} false {% endif %} |
|
||||
expected = %| false |
|
||||
assert_equal expected, Template.parse(text).render
|
||||
end
|
||||
|
||||
def test_zero_lqq_or_equal_one
|
||||
text = %| {% if 0 >= 0 %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render
|
||||
end
|
||||
|
||||
def test_strings
|
||||
text = %| {% if 'test' == 'test' %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render
|
||||
end
|
||||
|
||||
def test_strings_not_equal
|
||||
text = %| {% if 'test' != 'test' %} true {% else %} false {% endif %} |
|
||||
expected = %| false |
|
||||
assert_equal expected, Template.parse(text).render
|
||||
end
|
||||
|
||||
def test_var_strings_equal
|
||||
text = %| {% if var == "hello there!" %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render('var' => 'hello there!')
|
||||
end
|
||||
|
||||
def test_var_strings_are_not_equal
|
||||
text = %| {% if "hello there!" == var %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render('var' => 'hello there!')
|
||||
end
|
||||
|
||||
def test_var_and_long_string_are_equal
|
||||
text = %| {% if var == 'hello there!' %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render('var' => 'hello there!')
|
||||
end
|
||||
|
||||
|
||||
def test_var_and_long_string_are_equal_backwards
|
||||
text = %| {% if 'hello there!' == var %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render('var' => 'hello there!')
|
||||
end
|
||||
|
||||
#def test_is_nil
|
||||
# text = %| {% if var != nil %} true {% else %} false {% end %} |
|
||||
# @template.assigns = { 'var' => 'hello there!'}
|
||||
# expected = %| true |
|
||||
# assert_equal expected, @template.parse(text)
|
||||
#end
|
||||
|
||||
def test_is_collection_empty
|
||||
text = %| {% if array == empty %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render('array' => [])
|
||||
end
|
||||
|
||||
def test_is_not_collection_empty
|
||||
text = %| {% if array == empty %} true {% else %} false {% endif %} |
|
||||
expected = %| false |
|
||||
assert_equal expected, Template.parse(text).render('array' => [1,2,3])
|
||||
end
|
||||
|
||||
def test_nil
|
||||
text = %| {% if var == nil %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render('var' => nil)
|
||||
|
||||
text = %| {% if var == null %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render('var' => nil)
|
||||
end
|
||||
|
||||
def test_not_nil
|
||||
text = %| {% if var != nil %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render('var' => 1 )
|
||||
|
||||
text = %| {% if var != null %} true {% else %} false {% endif %} |
|
||||
expected = %| true |
|
||||
assert_equal expected, Template.parse(text).render('var' => 1 )
|
||||
end
|
||||
end # StatementsTest
|
||||
@@ -0,0 +1,26 @@
|
||||
require 'test_helper'
|
||||
|
||||
class UnlessElseTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_unless
|
||||
assert_template_result(' ',' {% unless true %} this text should not go into the output {% endunless %} ')
|
||||
assert_template_result(' this text should go into the output ',
|
||||
' {% unless false %} this text should go into the output {% endunless %} ')
|
||||
assert_template_result(' you rock ?','{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?')
|
||||
end
|
||||
|
||||
def test_unless_else
|
||||
assert_template_result(' YES ','{% unless true %} NO {% else %} YES {% endunless %}')
|
||||
assert_template_result(' YES ','{% unless false %} YES {% else %} NO {% endunless %}')
|
||||
assert_template_result(' YES ','{% unless "foo" %} NO {% else %} YES {% endunless %}')
|
||||
end
|
||||
|
||||
def test_unless_in_loop
|
||||
assert_template_result '23', '{% for i in choices %}{% unless i %}{{ forloop.index }}{% endunless %}{% endfor %}', 'choices' => [1, nil, false]
|
||||
end
|
||||
|
||||
def test_unless_else_in_loop
|
||||
assert_template_result ' TRUE 2 3 ', '{% for i in choices %}{% unless i %} {{ forloop.index }} {% else %} TRUE {% endunless %}{% endfor %}', 'choices' => [1, nil, false]
|
||||
end
|
||||
end # UnlessElseTest
|
||||
@@ -0,0 +1,74 @@
|
||||
require 'test_helper'
|
||||
|
||||
class TemplateTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_tokenize_strings
|
||||
assert_equal [' '], Template.new.send(:tokenize, ' ')
|
||||
assert_equal ['hello world'], Template.new.send(:tokenize, 'hello world')
|
||||
end
|
||||
|
||||
def test_tokenize_variables
|
||||
assert_equal ['{{funk}}'], Template.new.send(:tokenize, '{{funk}}')
|
||||
assert_equal [' ', '{{funk}}', ' '], Template.new.send(:tokenize, ' {{funk}} ')
|
||||
assert_equal [' ', '{{funk}}', ' ', '{{so}}', ' ', '{{brother}}', ' '], Template.new.send(:tokenize, ' {{funk}} {{so}} {{brother}} ')
|
||||
assert_equal [' ', '{{ funk }}', ' '], Template.new.send(:tokenize, ' {{ funk }} ')
|
||||
end
|
||||
|
||||
def test_tokenize_blocks
|
||||
assert_equal ['{%comment%}'], Template.new.send(:tokenize, '{%comment%}')
|
||||
assert_equal [' ', '{%comment%}', ' '], Template.new.send(:tokenize, ' {%comment%} ')
|
||||
|
||||
assert_equal [' ', '{%comment%}', ' ', '{%endcomment%}', ' '], Template.new.send(:tokenize, ' {%comment%} {%endcomment%} ')
|
||||
assert_equal [' ', '{% comment %}', ' ', '{% endcomment %}', ' '], Template.new.send(:tokenize, " {% comment %} {% endcomment %} ")
|
||||
end
|
||||
|
||||
def test_instance_assigns_persist_on_same_template_object_between_parses
|
||||
t = Template.new
|
||||
assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render
|
||||
assert_equal 'from instance assigns', t.parse("{{ foo }}").render
|
||||
end
|
||||
|
||||
def test_instance_assigns_persist_on_same_template_parsing_between_renders
|
||||
t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
|
||||
assert_equal 'foo', t.render
|
||||
assert_equal 'foofoo', t.render
|
||||
end
|
||||
|
||||
def test_custom_assigns_do_not_persist_on_same_template
|
||||
t = Template.new
|
||||
assert_equal 'from custom assigns', t.parse("{{ foo }}").render('foo' => 'from custom assigns')
|
||||
assert_equal '', t.parse("{{ foo }}").render
|
||||
end
|
||||
|
||||
def test_custom_assigns_squash_instance_assigns
|
||||
t = Template.new
|
||||
assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render
|
||||
assert_equal 'from custom assigns', t.parse("{{ foo }}").render('foo' => 'from custom assigns')
|
||||
end
|
||||
|
||||
def test_persistent_assigns_squash_instance_assigns
|
||||
t = Template.new
|
||||
assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render
|
||||
t.assigns['foo'] = 'from persistent assigns'
|
||||
assert_equal 'from persistent assigns', t.parse("{{ foo }}").render
|
||||
end
|
||||
|
||||
def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders
|
||||
t = Template.new
|
||||
t.assigns['number'] = lambda { @global ||= 0; @global += 1 }
|
||||
assert_equal '1', t.parse("{{number}}").render
|
||||
assert_equal '1', t.parse("{{number}}").render
|
||||
assert_equal '1', t.render
|
||||
@global = nil
|
||||
end
|
||||
|
||||
def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders
|
||||
t = Template.new
|
||||
assigns = {'number' => lambda { @global ||= 0; @global += 1 }}
|
||||
assert_equal '1', t.parse("{{number}}").render(assigns)
|
||||
assert_equal '1', t.parse("{{number}}").render(assigns)
|
||||
assert_equal '1', t.render(assigns)
|
||||
@global = nil
|
||||
end
|
||||
end # TemplateTest
|
||||
@@ -0,0 +1,170 @@
|
||||
require 'test_helper'
|
||||
|
||||
class VariableTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_variable
|
||||
var = Variable.new('hello')
|
||||
assert_equal 'hello', var.name
|
||||
end
|
||||
|
||||
def test_filters
|
||||
var = Variable.new('hello | textileze')
|
||||
assert_equal 'hello', var.name
|
||||
assert_equal [[:textileze,[]]], var.filters
|
||||
|
||||
var = Variable.new('hello | textileze | paragraph')
|
||||
assert_equal 'hello', var.name
|
||||
assert_equal [[:textileze,[]], [:paragraph,[]]], var.filters
|
||||
|
||||
var = Variable.new(%! hello | strftime: '%Y'!)
|
||||
assert_equal 'hello', var.name
|
||||
assert_equal [[:strftime,["'%Y'"]]], var.filters
|
||||
|
||||
var = Variable.new(%! 'typo' | link_to: 'Typo', true !)
|
||||
assert_equal %!'typo'!, var.name
|
||||
assert_equal [[:link_to,["'Typo'", "true"]]], var.filters
|
||||
|
||||
var = Variable.new(%! 'typo' | link_to: 'Typo', false !)
|
||||
assert_equal %!'typo'!, var.name
|
||||
assert_equal [[:link_to,["'Typo'", "false"]]], var.filters
|
||||
|
||||
var = Variable.new(%! 'foo' | repeat: 3 !)
|
||||
assert_equal %!'foo'!, var.name
|
||||
assert_equal [[:repeat,["3"]]], var.filters
|
||||
|
||||
var = Variable.new(%! 'foo' | repeat: 3, 3 !)
|
||||
assert_equal %!'foo'!, var.name
|
||||
assert_equal [[:repeat,["3","3"]]], var.filters
|
||||
|
||||
var = Variable.new(%! 'foo' | repeat: 3, 3, 3 !)
|
||||
assert_equal %!'foo'!, var.name
|
||||
assert_equal [[:repeat,["3","3","3"]]], var.filters
|
||||
|
||||
var = Variable.new(%! hello | strftime: '%Y, okay?'!)
|
||||
assert_equal 'hello', var.name
|
||||
assert_equal [[:strftime,["'%Y, okay?'"]]], var.filters
|
||||
|
||||
var = Variable.new(%! hello | things: "%Y, okay?", 'the other one'!)
|
||||
assert_equal 'hello', var.name
|
||||
assert_equal [[:things,["\"%Y, okay?\"","'the other one'"]]], var.filters
|
||||
end
|
||||
|
||||
def test_filter_with_date_parameter
|
||||
|
||||
var = Variable.new(%! '2006-06-06' | date: "%m/%d/%Y"!)
|
||||
assert_equal "'2006-06-06'", var.name
|
||||
assert_equal [[:date,["\"%m/%d/%Y\""]]], var.filters
|
||||
|
||||
end
|
||||
|
||||
def test_filters_without_whitespace
|
||||
var = Variable.new('hello | textileze | paragraph')
|
||||
assert_equal 'hello', var.name
|
||||
assert_equal [[:textileze,[]], [:paragraph,[]]], var.filters
|
||||
|
||||
var = Variable.new('hello|textileze|paragraph')
|
||||
assert_equal 'hello', var.name
|
||||
assert_equal [[:textileze,[]], [:paragraph,[]]], var.filters
|
||||
end
|
||||
|
||||
def test_symbol
|
||||
var = Variable.new("http://disney.com/logo.gif | image: 'med' ")
|
||||
assert_equal 'http://disney.com/logo.gif', var.name
|
||||
assert_equal [[:image,["'med'"]]], var.filters
|
||||
end
|
||||
|
||||
def test_string_single_quoted
|
||||
var = Variable.new(%| "hello" |)
|
||||
assert_equal '"hello"', var.name
|
||||
end
|
||||
|
||||
def test_string_double_quoted
|
||||
var = Variable.new(%| 'hello' |)
|
||||
assert_equal "'hello'", var.name
|
||||
end
|
||||
|
||||
def test_integer
|
||||
var = Variable.new(%| 1000 |)
|
||||
assert_equal "1000", var.name
|
||||
end
|
||||
|
||||
def test_float
|
||||
var = Variable.new(%| 1000.01 |)
|
||||
assert_equal "1000.01", var.name
|
||||
end
|
||||
|
||||
def test_string_with_special_chars
|
||||
var = Variable.new(%| 'hello! $!@.;"ddasd" ' |)
|
||||
assert_equal %|'hello! $!@.;"ddasd" '|, var.name
|
||||
end
|
||||
|
||||
def test_string_dot
|
||||
var = Variable.new(%| test.test |)
|
||||
assert_equal 'test.test', var.name
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
class VariableResolutionTest < Test::Unit::TestCase
|
||||
include Liquid
|
||||
|
||||
def test_simple_variable
|
||||
template = Template.parse(%|{{test}}|)
|
||||
assert_equal 'worked', template.render('test' => 'worked')
|
||||
assert_equal 'worked wonderfully', template.render('test' => 'worked wonderfully')
|
||||
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')
|
||||
end
|
||||
|
||||
def test_ignore_unknown
|
||||
template = Template.parse(%|{{ test }}|)
|
||||
assert_equal '', template.render
|
||||
end
|
||||
|
||||
def test_hash_scoping
|
||||
template = Template.parse(%|{{ test.test }}|)
|
||||
assert_equal 'worked', template.render('test' => {'test' => 'worked'})
|
||||
end
|
||||
|
||||
def test_preset_assigns
|
||||
template = Template.parse(%|{{ test }}|)
|
||||
template.assigns['test'] = 'worked'
|
||||
assert_equal 'worked', template.render
|
||||
end
|
||||
|
||||
def test_reuse_parsed_template
|
||||
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({'greeting'=>'Goodbye'}, template.assigns)
|
||||
end
|
||||
|
||||
def test_assigns_not_polluted_from_template
|
||||
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
|
||||
end
|
||||
|
||||
def test_hash_with_default_proc
|
||||
template = Template.parse(%|Hello {{ test }}|)
|
||||
assigns = Hash.new { |h,k| raise "Unknown variable '#{k}'" }
|
||||
assigns['test'] = 'Tobi'
|
||||
assert_equal 'Hello Tobi', template.render!(assigns)
|
||||
assigns.delete('test')
|
||||
e = assert_raises(RuntimeError) {
|
||||
template.render!(assigns)
|
||||
}
|
||||
assert_equal "Unknown variable 'test'", e.message
|
||||
end
|
||||
end # VariableTest
|
||||
Reference in New Issue
Block a user