liquid 4.0.3 → 5.1.0

data/test/unit/condition_unit_test.rb

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

data/test/unit/file_system_unit_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class FileSystemUnitTest < Minitest::Test
@@ -11,8 +13,8 @@ class FileSystemUnitTest < Minitest::Test
 
   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_equal("/some/path/_mypartial.liquid", file_system.full_path("mypartial"))
+    assert_equal("/some/path/dir/_mypartial.liquid", file_system.full_path("dir/mypartial"))
 
     assert_raises(FileSystemError) do
       file_system.full_path("../dir/mypartial")
@@ -29,7 +31,7 @@ class FileSystemUnitTest < Minitest::Test
 
   def test_custom_template_filename_patterns
     file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
-    assert_equal "/some/path/mypartial.html", file_system.full_path("mypartial")
-    assert_equal "/some/path/dir/mypartial.html", file_system.full_path("dir/mypartial")
+    assert_equal("/some/path/mypartial.html", file_system.full_path("mypartial"))
+    assert_equal("/some/path/dir/mypartial.html", file_system.full_path("dir/mypartial"))
   end
 end # FileSystemTest

data/test/unit/i18n_unit_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class I18nUnitTest < Minitest::Test
@@ -8,15 +10,15 @@ class I18nUnitTest < Minitest::Test
   end
 
   def test_simple_translate_string
-    assert_equal "less is more", @i18n.translate("simple")
+    assert_equal("less is more", @i18n.translate("simple"))
   end
 
   def test_nested_translate_string
-    assert_equal "something wasn't right", @i18n.translate("errors.syntax.oops")
+    assert_equal("something wasn't right", @i18n.translate("errors.syntax.oops"))
   end
 
   def test_single_string_interpolation
-    assert_equal "something different", @i18n.translate("whatever", something: "different")
+    assert_equal("something different", @i18n.translate("whatever", something: "different"))
   end
 
   # def test_raises_translation_error_on_undefined_interpolation_key
@@ -26,12 +28,12 @@ class I18nUnitTest < Minitest::Test
   # end
 
   def test_raises_unknown_translation
-    assert_raises I18n::TranslationError do
+    assert_raises(I18n::TranslationError) do
       @i18n.translate("doesnt_exist")
     end
   end
 
   def test_sets_default_path_to_en
-    assert_equal I18n::DEFAULT_LOCALE, I18n.new.path
+    assert_equal(I18n::DEFAULT_LOCALE, I18n.new.path)
   end
 end

data/test/unit/lexer_unit_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class LexerUnitTest < Minitest::Test
@@ -5,42 +7,42 @@ class LexerUnitTest < Minitest::Test
 
   def test_strings
     tokens = Lexer.new(%( 'this is a test""' "wat 'lol'")).tokenize
-    assert_equal [[:string, %('this is a test""')], [:string, %("wat 'lol'")], [:end_of_string]], tokens
+    assert_equal([[:string, %('this is a test""')], [:string, %("wat 'lol'")], [:end_of_string]], tokens)
   end
 
   def test_integer
     tokens = Lexer.new('hi 50').tokenize
-    assert_equal [[:id, 'hi'], [:number, '50'], [:end_of_string]], tokens
+    assert_equal([[:id, 'hi'], [:number, '50'], [:end_of_string]], tokens)
   end
 
   def test_float
     tokens = Lexer.new('hi 5.0').tokenize
-    assert_equal [[:id, 'hi'], [:number, '5.0'], [:end_of_string]], tokens
+    assert_equal([[:id, 'hi'], [:number, '5.0'], [:end_of_string]], tokens)
   end
 
   def test_comparison
     tokens = Lexer.new('== <> contains ').tokenize
-    assert_equal [[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens
+    assert_equal([[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens)
   end
 
   def test_specials
     tokens = Lexer.new('| .:').tokenize
-    assert_equal [[:pipe, '|'], [:dot, '.'], [:colon, ':'], [:end_of_string]], tokens
+    assert_equal([[:pipe, '|'], [:dot, '.'], [:colon, ':'], [:end_of_string]], tokens)
     tokens = Lexer.new('[,]').tokenize
-    assert_equal [[:open_square, '['], [:comma, ','], [:close_square, ']'], [:end_of_string]], tokens
+    assert_equal([[:open_square, '['], [:comma, ','], [:close_square, ']'], [:end_of_string]], tokens)
   end
 
   def test_fancy_identifiers
     tokens = Lexer.new('hi five?').tokenize
-    assert_equal [[:id, 'hi'], [:id, 'five?'], [:end_of_string]], tokens
+    assert_equal([[:id, 'hi'], [:id, 'five?'], [:end_of_string]], tokens)
 
     tokens = Lexer.new('2foo').tokenize
-    assert_equal [[:number, '2'], [:id, 'foo'], [:end_of_string]], tokens
+    assert_equal([[:number, '2'], [:id, 'foo'], [:end_of_string]], tokens)
   end
 
   def test_whitespace
     tokens = Lexer.new("five|\n\t ==").tokenize
-    assert_equal [[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens
+    assert_equal([[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens)
   end
 
   def test_unexpected_character

data/test/{integration → unit}/parse_tree_visitor_test.rb

@@ -26,6 +26,13 @@ class ParseTreeVisitorTest < Minitest::Test
     )
   end
 
+  def test_echo
+    assert_equal(
+      ["test"],
+      visit(%({% echo test %}))
+    )
+  end
+
   def test_if_condition
     assert_equal(
       ["test"],
@@ -152,6 +159,13 @@ class ParseTreeVisitorTest < Minitest::Test
     )
   end
 
+  def test_for_range
+    assert_equal(
+      ["test"],
+      visit(%({% for x in (1..test) %}{% endfor %}))
+    )
+  end
+
   def test_tablerow_in
     assert_equal(
       ["test"],
@@ -227,7 +241,7 @@ class ParseTreeVisitorTest < Minitest::Test
       [[nil, [
         [nil, [[nil, [["other", []]]]]],
         ["test", []],
-        ["xs", []]
+        ["xs", []],
       ]]],
       traversal(%({% for x in xs offset: test %}{{ other }}{% endfor %})).visit
     )
@@ -238,7 +252,7 @@ class ParseTreeVisitorTest < Minitest::Test
   def traversal(template)
     ParseTreeVisitor
       .for(Template.parse(template).root)
-      .add_callback_for(VariableLookup, &:name)
+      .add_callback_for(VariableLookup) { |node| node.name } # rubocop:disable Style/SymbolProc
   end
 
   def visit(template)

data/test/unit/parser_unit_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class ParserUnitTest < Minitest::Test
@@ -5,72 +7,72 @@ class ParserUnitTest < Minitest::Test
 
   def test_consume
     p = Parser.new("wat: 7")
-    assert_equal 'wat', p.consume(:id)
-    assert_equal ':', p.consume(:colon)
-    assert_equal '7', p.consume(:number)
+    assert_equal('wat', p.consume(:id))
+    assert_equal(':', p.consume(:colon))
+    assert_equal('7', p.consume(:number))
   end
 
   def test_jump
     p = Parser.new("wat: 7")
     p.jump(2)
-    assert_equal '7', p.consume(:number)
+    assert_equal('7', p.consume(:number))
   end
 
   def test_consume?
     p = Parser.new("wat: 7")
-    assert_equal 'wat', p.consume?(:id)
-    assert_equal false, p.consume?(:dot)
-    assert_equal ':', p.consume(:colon)
-    assert_equal '7', p.consume?(:number)
+    assert_equal('wat', p.consume?(:id))
+    assert_equal(false, p.consume?(:dot))
+    assert_equal(':', p.consume(:colon))
+    assert_equal('7', p.consume?(:number))
   end
 
   def test_id?
     p = Parser.new("wat 6 Peter Hegemon")
-    assert_equal 'wat', p.id?('wat')
-    assert_equal false, p.id?('endgame')
-    assert_equal '6', p.consume(:number)
-    assert_equal 'Peter', p.id?('Peter')
-    assert_equal false, p.id?('Achilles')
+    assert_equal('wat', p.id?('wat'))
+    assert_equal(false, p.id?('endgame'))
+    assert_equal('6', p.consume(:number))
+    assert_equal('Peter', p.id?('Peter'))
+    assert_equal(false, p.id?('Achilles'))
   end
 
   def test_look
     p = Parser.new("wat 6 Peter Hegemon")
-    assert_equal true, p.look(:id)
-    assert_equal 'wat', p.consume(:id)
-    assert_equal false, p.look(:comparison)
-    assert_equal true, p.look(:number)
-    assert_equal true, p.look(:id, 1)
-    assert_equal false, p.look(:number, 1)
+    assert_equal(true, p.look(:id))
+    assert_equal('wat', p.consume(:id))
+    assert_equal(false, p.look(:comparison))
+    assert_equal(true, p.look(:number))
+    assert_equal(true, p.look(:id, 1))
+    assert_equal(false, p.look(:number, 1))
   end
 
   def test_expressions
     p = Parser.new("hi.there hi?[5].there? hi.there.bob")
-    assert_equal 'hi.there', p.expression
-    assert_equal 'hi?[5].there?', p.expression
-    assert_equal 'hi.there.bob', p.expression
+    assert_equal('hi.there', p.expression)
+    assert_equal('hi?[5].there?', p.expression)
+    assert_equal('hi.there.bob', p.expression)
 
     p = Parser.new("567 6.0 'lol' \"wut\"")
-    assert_equal '567', p.expression
-    assert_equal '6.0', p.expression
-    assert_equal "'lol'", p.expression
-    assert_equal '"wut"', p.expression
+    assert_equal('567', p.expression)
+    assert_equal('6.0', p.expression)
+    assert_equal("'lol'", p.expression)
+    assert_equal('"wut"', p.expression)
   end
 
   def test_ranges
     p = Parser.new("(5..7) (1.5..9.6) (young..old) (hi[5].wat..old)")
-    assert_equal '(5..7)', p.expression
-    assert_equal '(1.5..9.6)', p.expression
-    assert_equal '(young..old)', p.expression
-    assert_equal '(hi[5].wat..old)', p.expression
+    assert_equal('(5..7)', p.expression)
+    assert_equal('(1.5..9.6)', p.expression)
+    assert_equal('(young..old)', p.expression)
+    assert_equal('(hi[5].wat..old)', p.expression)
   end
 
   def test_arguments
     p = Parser.new("filter: hi.there[5], keyarg: 7")
-    assert_equal 'filter', p.consume(:id)
-    assert_equal ':', p.consume(:colon)
-    assert_equal 'hi.there[5]', p.argument
-    assert_equal ',', p.consume(:comma)
-    assert_equal 'keyarg: 7', p.argument
+    assert_equal('filter', p.consume(:id))
+    assert_equal(':', p.consume(:colon))
+    assert_equal('hi.there[5]', p.argument)
+    assert_equal(',', p.consume(:comma))
+    assert_equal('keyarg: 7', p.argument)
   end
 
   def test_invalid_expression

data/test/unit/partial_cache_unit_test.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class PartialCacheUnitTest < Minitest::Test
+  def test_uses_the_file_system_register_if_present
+    context = Liquid::Context.build(
+      registers: {
+        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
+      }
+    )
+
+    partial = Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new
+    )
+
+    assert_equal('my partial body', partial.render)
+  end
+
+  def test_reads_from_the_file_system_only_once_per_file
+    file_system = StubFileSystem.new('my_partial' => 'some partial body')
+    context     = Liquid::Context.build(
+      registers: { file_system: file_system }
+    )
+
+    2.times do
+      Liquid::PartialCache.load(
+        'my_partial',
+        context: context,
+        parse_context: Liquid::ParseContext.new
+      )
+    end
+
+    assert_equal(1, file_system.file_read_count)
+  end
+
+  def test_cache_state_is_stored_per_context
+    parse_context      = Liquid::ParseContext.new
+    shared_file_system = StubFileSystem.new(
+      'my_partial' => 'my shared value'
+    )
+    context_one = Liquid::Context.build(
+      registers: {
+        file_system: shared_file_system,
+      }
+    )
+    context_two = Liquid::Context.build(
+      registers: {
+        file_system: shared_file_system,
+      }
+    )
+
+    2.times do
+      Liquid::PartialCache.load(
+        'my_partial',
+        context: context_one,
+        parse_context: parse_context
+      )
+    end
+
+    Liquid::PartialCache.load(
+      'my_partial',
+      context: context_two,
+      parse_context: parse_context
+    )
+
+    assert_equal(2, shared_file_system.file_read_count)
+  end
+
+  def test_cache_is_not_broken_when_a_different_parse_context_is_used
+    file_system = StubFileSystem.new('my_partial' => 'some partial body')
+    context     = Liquid::Context.build(
+      registers: { file_system: file_system }
+    )
+
+    Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new(my_key: 'value one')
+    )
+    Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new(my_key: 'value two')
+    )
+
+    # Technically what we care about is that the file was parsed twice,
+    # but measuring file reads is an OK proxy for this.
+    assert_equal(1, file_system.file_read_count)
+  end
+
+  def test_uses_default_template_factory_when_no_template_factory_found_in_register
+    context = Liquid::Context.build(
+      registers: {
+        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
+      }
+    )
+
+    partial = Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new
+    )
+
+    assert_equal('my partial body', partial.render)
+  end
+
+  def test_uses_template_factory_register_if_present
+    template_factory = StubTemplateFactory.new
+    context = Liquid::Context.build(
+      registers: {
+        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
+        template_factory: template_factory,
+      }
+    )
+
+    partial = Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new
+    )
+
+    assert_equal('my partial body', partial.render)
+    assert_equal(1, template_factory.count)
+  end
+end