padrino-helpers 0.12.8.1 → 0.12.9

data/test/test_format_helpers.rb

@@ -57,25 +57,6 @@ describe "FormatHelpers" do
     end
   end
 
-  describe 'for #pluralize method' do
-    it 'should return singular count for 1 item collections' do
-      actual_text = pluralize(1, 'person')
-      assert_equal '1 person', actual_text
-    end
-    it 'should return plural count for empty collections' do
-      actual_text = pluralize(0, 'person')
-      assert_equal '0 people', actual_text
-    end
-    it 'should return plural count for many collections' do
-      actual_text =  pluralize(2, 'person')
-      assert_equal '2 people', actual_text
-    end
-    it 'should return pluralized word specified as argument' do
-      actual_text =  pluralize(3, 'person', 'users')
-      assert_equal '3 users', actual_text
-    end
-  end
-
   describe 'for #word_wrap method' do
     it 'should return proper formatting for 8 max width' do
       actual_text = word_wrap('Once upon a time', :line_width => 8)
@@ -158,6 +139,8 @@ describe "FormatHelpers" do
   end
 
   describe 'for #time_ago_in_words method' do
+    _DAY = 24*60*60
+
     it 'should less than 5 seconds' do
       assert_equal 'less than 5 seconds', time_ago_in_words(Time.now, true)
     end
@@ -177,52 +160,49 @@ describe "FormatHelpers" do
       assert_equal 'less than a minute', time_ago_in_words(Time.now)
     end
     it 'should display yesterday' do
-      assert_equal '1 day', time_ago_in_words(1.day.ago)
+      assert_equal '1 day', time_ago_in_words(Time.now - _DAY)
     end
     it 'should display tomorrow' do
-      assert_equal '1 day', time_ago_in_words(1.day.from_now)
+      assert_equal '1 day', time_ago_in_words(Time.now + _DAY)
     end
     it 'should return future number of days' do
-      assert_equal '4 days', time_ago_in_words(4.days.from_now)
+      assert_equal '4 days', time_ago_in_words(Time.now + 4*_DAY)
     end
     it 'should return past days ago' do
-      assert_equal '4 days', time_ago_in_words(4.days.ago)
+      assert_equal '4 days', time_ago_in_words(Time.now - 4*_DAY)
     end
     it 'should return formatted archived date' do
-      assert_equal '3 months', time_ago_in_words(100.days.ago)
+      assert_equal '3 months', time_ago_in_words(Time.now - 100*_DAY)
     end
     it 'should return formatted archived year date' do
-      assert_equal 'over 1 year', time_ago_in_words(500.days.ago)
+      assert_equal 'over 1 year', time_ago_in_words(Time.now - 500*_DAY)
     end
     it 'should display now as a minute ago' do
-      assert_equal '1 minute', time_ago_in_words(1.minute.ago)
+      assert_equal '1 minute', time_ago_in_words(Time.now - 60)
     end
     it 'should display a few minutes ago' do
-      assert_equal '4 minutes', time_ago_in_words(4.minute.ago)
+      assert_equal '4 minutes', time_ago_in_words(Time.now - 4*60)
     end
     it 'should display an hour ago' do
-      assert_equal 'about 1 hour', time_ago_in_words(1.hour.ago + 5.minutes.ago.sec)
+      assert_equal 'about 1 hour', time_ago_in_words(Time.now - 60*60 + 5)
     end
     it 'should display a few hours ago' do
-      assert_equal 'about 3 hours', time_ago_in_words(3.hour.ago + 5.minutes.ago.sec)
-    end
-    it 'should display a day ago' do
-      assert_equal '1 day', time_ago_in_words(1.day.ago)
+      assert_equal 'about 3 hours', time_ago_in_words(Time.now - 3*60*60 + 5*60)
     end
     it 'should display a few days ago' do
-      assert_equal '5 days', time_ago_in_words(5.days.ago - 5.minutes.ago.sec)
+      assert_equal '5 days', time_ago_in_words(Time.now - 5*_DAY - 5*60)
     end
     it 'should display a month ago' do
-      assert_equal 'about 1 month', time_ago_in_words(32.days.ago + 5.minutes.ago.sec)
+      assert_equal 'about 1 month', time_ago_in_words(Time.now - 32*_DAY + 5*60)
     end
     it 'should display a few months ago' do
-      assert_equal '6 months', time_ago_in_words(180.days.ago - 5.minutes.ago.sec)
+      assert_equal '6 months', time_ago_in_words(Time.now - 180*_DAY - 5*60)
     end
     it 'should display a year ago' do
-      assert_equal 'about 1 year', time_ago_in_words(365.days.ago - 5.minutes.ago.sec)
+      assert_equal 'about 1 year', time_ago_in_words(Time.now - 365*_DAY - 5*60)
     end
     it 'should display a few years ago' do
-      assert_equal 'over 7 years', time_ago_in_words(2800.days.ago - 5.minutes.ago.sec)
+      assert_equal 'over 7 years', time_ago_in_words(Time.now - 2800*_DAY - 5*60)
     end
   end
 

data/test/test_helpers.rb

@@ -7,4 +7,12 @@ describe "Padrino::Helpers" do
     end
     assert_equal '<div>bar</div>', Foo.new.content_tag(:div, 'bar')
   end
+
+  it 'should not overwrite default_builder setting' do
+    mock_app do
+      set :default_builder, 'FancyBuilder'
+      register Padrino::Helpers
+    end
+    assert_equal 'FancyBuilder', @app.default_builder
+  end
 end

data/test/test_output_helpers.rb

@@ -8,150 +8,150 @@ describe "OutputHelpers" do
 
   describe 'for #content_for method' do
     it 'should work for erb templates' do
-      visit '/erb/content_for'
-      assert_have_selector '.demo h1', :content => "This is content yielded from a content_for", :count => 1
-      assert_have_selector '.demo2 h1', :content => "This is content yielded with name Johnny Smith", :count => 1
-      assert_have_no_selector '.demo3 p', :content => "One", :class => "duplication"
-      assert_have_selector '.demo3 p', :content => "Two", :class => "duplication"
+      get "/erb/content_for"
+      assert_response_has_tag '.demo h1', :content => "This is content yielded from a content_for", :count => 1
+      assert_response_has_tag '.demo2 h1', :content => "This is content yielded with name Johnny Smith", :count => 1
+      assert_response_has_no_tag '.demo3 p', :content => "One", :class => "duplication"
+      assert_response_has_tag '.demo3 p', :content => "Two", :class => "duplication"
     end
 
     it 'should work for haml templates' do
-      visit '/haml/content_for'
-      assert_have_selector '.demo h1', :content => "This is content yielded from a content_for", :count => 1
-      assert_have_selector '.demo2 h1', :content => "This is content yielded with name Johnny Smith", :count => 1
-      assert_have_no_selector '.demo3 p', :content => "One", :class => "duplication"
-      assert_have_selector '.demo3 p', :content => "Two", :class => "duplication"
+      get "/haml/content_for"
+      assert_response_has_tag '.demo h1', :content => "This is content yielded from a content_for", :count => 1
+      assert_response_has_tag '.demo2 h1', :content => "This is content yielded with name Johnny Smith", :count => 1
+      assert_response_has_no_tag '.demo3 p', :content => "One", :class => "duplication"
+      assert_response_has_tag '.demo3 p', :content => "Two", :class => "duplication"
     end
 
     it 'should work for slim templates' do
-      visit '/slim/content_for'
-      assert_have_selector '.demo h1', :content => "This is content yielded from a content_for", :count => 1
-      assert_have_selector '.demo2 h1', :content => "This is content yielded with name Johnny Smith", :count => 1
-      assert_have_no_selector '.demo3 p', :content => "One", :class => "duplication"
-      assert_have_selector '.demo3 p', :content => "Two", :class => "duplication"
+      get "/slim/content_for"
+      assert_response_has_tag '.demo h1', :content => "This is content yielded from a content_for", :count => 1
+      assert_response_has_tag '.demo2 h1', :content => "This is content yielded with name Johnny Smith", :count => 1
+      assert_response_has_no_tag '.demo3 p', :content => "One", :class => "duplication"
+      assert_response_has_tag '.demo3 p', :content => "Two", :class => "duplication"
     end
   end # content_for
 
   describe "for #content_for? method" do
     it 'should work for erb templates' do
-      visit '/erb/content_for'
-      assert_have_selector '.demo_has_content', :content => "true"
-      assert_have_selector '.fake_has_content', :content => "false"
+      get "/erb/content_for"
+      assert_response_has_tag '.demo_has_content', :content => "true"
+      assert_response_has_tag '.fake_has_content', :content => "false"
     end
 
     it 'should work for haml templates' do
-      visit '/haml/content_for'
-      assert_have_selector '.demo_has_content', :content => "true"
-      assert_have_selector '.fake_has_content', :content => "false"
+      get "/haml/content_for"
+      assert_response_has_tag '.demo_has_content', :content => "true"
+      assert_response_has_tag '.fake_has_content', :content => "false"
     end
 
     it 'should work for slim templates' do
-      visit '/slim/content_for'
-      assert_have_selector '.demo_has_content', :content => "true"
-      assert_have_selector '.fake_has_content', :content => "false"
+      get "/slim/content_for"
+      assert_response_has_tag '.demo_has_content', :content => "true"
+      assert_response_has_tag '.fake_has_content', :content => "false"
     end
   end # content_for?
 
   describe 'for #capture_html method' do
     it 'should work for erb templates' do
-      visit '/erb/capture_concat'
-      assert_have_selector 'p span', :content => "Captured Line 1", :count => 1
-      assert_have_selector 'p span', :content => "Captured Line 2", :count => 1
+      get "/erb/capture_concat"
+      assert_response_has_tag 'p span', :content => "Captured Line 1", :count => 1
+      assert_response_has_tag 'p span', :content => "Captured Line 2", :count => 1
     end
 
     it 'should work for haml templates' do
-      visit '/haml/capture_concat'
-      assert_have_selector 'p span', :content => "Captured Line 1", :count => 1
-      assert_have_selector 'p span', :content => "Captured Line 2", :count => 1
+      get "/haml/capture_concat"
+      assert_response_has_tag 'p span', :content => "Captured Line 1", :count => 1
+      assert_response_has_tag 'p span', :content => "Captured Line 2", :count => 1
     end
 
     it 'should work for slim templates' do
-      visit '/slim/capture_concat'
-      assert_have_selector 'p span', :content => "Captured Line 1", :count => 1
-      assert_have_selector 'p span', :content => "Captured Line 2", :count => 1
+      get "/slim/capture_concat"
+      assert_response_has_tag 'p span', :content => "Captured Line 1", :count => 1
+      assert_response_has_tag 'p span', :content => "Captured Line 2", :count => 1
     end
   end
 
   describe 'for #concat_content method' do
     it 'should work for erb templates' do
-      visit '/erb/capture_concat'
-      assert_have_selector 'p', :content => "Concat Line 3", :count => 1
+      get "/erb/capture_concat"
+      assert_response_has_tag 'p', :content => "Concat Line 3", :count => 1
     end
 
     it 'should work for haml templates' do
-      visit '/haml/capture_concat'
-      assert_have_selector 'p', :content => "Concat Line 3", :count => 1
+      get "/haml/capture_concat"
+      assert_response_has_tag 'p', :content => "Concat Line 3", :count => 1
     end
 
     it 'should work for slim templates' do
-      visit '/slim/capture_concat'
-      assert_have_selector 'p', :content => "Concat Line 3", :count => 1
+      get "/slim/capture_concat"
+      assert_response_has_tag 'p', :content => "Concat Line 3", :count => 1
     end
   end
 
   describe 'for #block_is_template?' do
     it 'should work for erb templates' do
-      visit '/erb/capture_concat'
-      assert_have_selector 'p', :content => "The erb block passed in is a template", :class => 'is_template', :count => 1
-      assert_have_no_selector 'p', :content => "The ruby block passed in is a template", :class => 'is_template', :count => 1
+      get "/erb/capture_concat"
+      assert_response_has_tag 'p', :content => "The erb block passed in is a template", :class => 'is_template', :count => 1
+      assert_response_has_no_tag 'p', :content => "The ruby block passed in is a template", :class => 'is_template', :count => 1
     end
 
     it 'should work for haml templates' do
-      visit '/haml/capture_concat'
-      assert_have_selector 'p', :content => "The haml block passed in is a template", :class => 'is_template', :count => 1
-      assert_have_no_selector 'p', :content => "The ruby block passed in is a template", :class => 'is_template', :count => 1
+      get "/haml/capture_concat"
+      assert_response_has_tag 'p', :content => "The haml block passed in is a template", :class => 'is_template', :count => 1
+      assert_response_has_no_tag 'p', :content => "The ruby block passed in is a template", :class => 'is_template', :count => 1
     end
 
     it 'should work for slim templates' do
-      visit '/slim/capture_concat'
-      assert_have_selector 'p', :content => "The slim block passed in is a template", :class => 'is_template', :count => 1
-      assert_have_no_selector 'p', :content => "The ruby block passed in is a template", :class => 'is_template', :count => 1
+      get "/slim/capture_concat"
+      assert_response_has_tag 'p', :content => "The slim block passed in is a template", :class => 'is_template', :count => 1
+      assert_response_has_no_tag 'p', :content => "The ruby block passed in is a template", :class => 'is_template', :count => 1
     end
   end
 
   describe 'for #current_engine method' do
     it 'should detect correctly current engine for erb' do
-      visit '/erb/current_engine'
-      assert_have_selector 'p.start', :content => "erb"
-      assert_have_selector 'p.haml',  :content => "haml"
-      assert_have_selector 'p.erb',   :content => "erb"
-      assert_have_selector 'p.slim',  :content => "slim"
-      assert_have_selector 'p.end',   :content => "erb"
+      get "/erb/current_engine"
+      assert_response_has_tag 'p.start', :content => "erb"
+      assert_response_has_tag 'p.haml',  :content => "haml"
+      assert_response_has_tag 'p.erb',   :content => "erb"
+      assert_response_has_tag 'p.slim',  :content => "slim"
+      assert_response_has_tag 'p.end',   :content => "erb"
     end
 
     it 'should detect correctly current engine for haml' do
-      visit '/haml/current_engine'
-      assert_have_selector 'p.start', :content => "haml"
-      assert_have_selector 'p.haml',  :content => "haml"
-      assert_have_selector 'p.erb',   :content => "erb"
-      assert_have_selector 'p.slim',  :content => "slim"
-      assert_have_selector 'p.end',   :content => "haml"
+      get "/haml/current_engine"
+      assert_response_has_tag 'p.start', :content => "haml"
+      assert_response_has_tag 'p.haml',  :content => "haml"
+      assert_response_has_tag 'p.erb',   :content => "erb"
+      assert_response_has_tag 'p.slim',  :content => "slim"
+      assert_response_has_tag 'p.end',   :content => "haml"
     end
 
     it 'should detect correctly current engine for slim' do
-      visit '/slim/current_engine'
-      assert_have_selector 'p.start', :content => "slim"
-      assert_have_selector 'p.haml',  :content => "haml"
-      assert_have_selector 'p.erb',   :content => "erb"
-      assert_have_selector 'p.slim',  :content => "slim"
-      assert_have_selector 'p.end',   :content => "slim"
+      get "/slim/current_engine"
+      assert_response_has_tag 'p.start', :content => "slim"
+      assert_response_has_tag 'p.haml',  :content => "haml"
+      assert_response_has_tag 'p.erb',   :content => "erb"
+      assert_response_has_tag 'p.slim',  :content => "slim"
+      assert_response_has_tag 'p.end',   :content => "slim"
     end
   end
 
   describe 'for #partial method in simple sinatra application' do
     it 'should properly output in erb' do
-      visit '/erb/simple_partial'
-      assert_have_selector 'p.erb',  :content => "erb"
+      get "/erb/simple_partial"
+      assert_response_has_tag 'p.erb',  :content => "erb"
     end
 
     it 'should properly output in haml' do
-      visit '/haml/simple_partial'
-      assert_have_selector 'p.haml',  :content => "haml"
+      get "/haml/simple_partial"
+      assert_response_has_tag 'p.haml',  :content => "haml"
     end
 
     it 'should properly output in slim' do
-      visit '/slim/simple_partial'
-      assert_have_selector 'p.slim',  :content => "slim"
+      get "/slim/simple_partial"
+      assert_response_has_tag 'p.slim',  :content => "slim"
     end
   end
 end

data/test/test_render_helpers.rb

@@ -7,219 +7,261 @@ describe "RenderHelpers" do
   end
 
   describe 'for #partial method and object' do
-    before { visit '/partial/object' }
+    before { get "/partial/object" }
     it 'should render partial html with object' do
-      assert_have_selector "h1", :content => "User name is John"
+      assert_response_has_tag "h1", :content => "User name is John"
     end
     it 'should have no counter index for single item' do
-      assert_have_no_selector "p", :content => "My counter is 1", :count => 1
+      assert_response_has_no_tag "p", :content => "My counter is 1", :count => 1
     end
     it 'should include extra locals information' do
-      assert_have_selector 'p', :content => "Extra is bar"
+      assert_response_has_tag 'p', :content => "Extra is bar"
     end
   end
 
   describe 'for #partial method and collection' do
-    before { visit '/partial/collection' }
+    before { get "/partial/collection" }
     it 'should render partial html with collection' do
-      assert_have_selector "h1", :content => "User name is John"
-      assert_have_selector "h1", :content => "User name is Billy"
+      assert_response_has_tag "h1", :content => "User name is John"
+      assert_response_has_tag "h1", :content => "User name is Billy"
     end
     it 'should include counter which contains item index' do
-      assert_have_selector "p", :content => "My counter is 1"
-      assert_have_selector "p", :content => "My counter is 2"
+      assert_response_has_tag "p", :content => "My counter is 1"
+      assert_response_has_tag "p", :content => "My counter is 2"
     end
     it 'should include extra locals information' do
-      assert_have_selector 'p', :content => "Extra is bar"
+      assert_response_has_tag 'p', :content => "Extra is bar"
     end
   end
 
   describe 'for #partial with ext and collection' do
-    before { visit '/partial/collection.ext' }
+    before { get "/partial/collection.ext" }
     it 'should not fail horribly with `invalid locals key` RuntimeError' do
-      assert_have_selector "h1", :content => "User name is John"
+      assert_response_has_tag "h1", :content => "User name is John"
     end
   end
 
   describe 'for #partial method and locals' do
-    before { visit '/partial/locals' }
+    before { get "/partial/locals" }
     it 'should render partial html with locals' do
-      assert_have_selector "h1", :content => "User name is John"
+      assert_response_has_tag "h1", :content => "User name is John"
     end
     it 'should have no counter index for single item' do
-      assert_have_no_selector "p", :content => "My counter is 1", :count => 1
+      assert_response_has_no_tag "p", :content => "My counter is 1", :count => 1
     end
     it 'should include extra locals information' do
-      assert_have_selector 'p', :content => "Extra is bar"
+      assert_response_has_tag 'p', :content => "Extra is bar"
     end
   end
 
   describe 'for #partial method taking a path starting with forward slash' do
-    before { visit '/partial/foward_slash' }
+    before { get "/partial/foward_slash" }
     it 'should render partial without throwing an error' do
-      assert_have_selector "h1", :content => "User name is John"
+      assert_response_has_tag "h1", :content => "User name is John"
     end
   end
 
   describe 'for #partial method with unsafe engine' do
     it 'should render partial without escaping it' do
-      visit '/partial/unsafe'
-      assert_have_selector "h1", :content => "User name is John"
+      get "/partial/unsafe"
+      assert_response_has_tag "h1", :content => "User name is John"
     end
     it 'should render partial object without escaping it' do
-      visit '/partial/unsafe_one'
-      assert_have_selector "h1", :content => "User name is Mary"
+      get "/partial/unsafe_one"
+      assert_response_has_tag "h1", :content => "User name is Mary"
     end
     it 'should render partial collection without escaping it' do
-      visit '/partial/unsafe_many'
-      assert_have_selector "h1", :content => "User name is John"
-      assert_have_selector "h1", :content => "User name is Mary"
+      get "/partial/unsafe_many"
+      assert_response_has_tag "h1", :content => "User name is John"
+      assert_response_has_tag "h1", :content => "User name is Mary"
     end
     it 'should render unsafe partial without escaping it' do
-      visit '/partial/unsafe?block=%3Cevil%3E'
-      assert_have_selector "h1", :content => "User name is John"
-      assert_have_selector "evil"
+      get "/partial/unsafe?block=%3Cevil%3E"
+      assert_response_has_tag "h1", :content => "User name is John"
+      assert_response_has_tag "evil"
     end
     it 'should render unsafe partial object without escaping it' do
-      visit '/partial/unsafe_one?block=%3Cevil%3E'
-      assert_have_selector "h1", :content => "User name is Mary"
-      assert_have_selector "evil"
+      get "/partial/unsafe_one?block=%3Cevil%3E"
+      assert_response_has_tag "h1", :content => "User name is Mary"
+      assert_response_has_tag "evil"
     end
     it 'should render unsafe partial collection without escaping it' do
-      visit '/partial/unsafe_many?block=%3Cevil%3E'
-      assert_have_selector "h1", :content => "User name is John"
-      assert_have_selector "h1", :content => "User name is Mary"
-      assert_have_selector "evil"
+      get "/partial/unsafe_many?block=%3Cevil%3E"
+      assert_response_has_tag "h1", :content => "User name is John"
+      assert_response_has_tag "h1", :content => "User name is Mary"
+      assert_response_has_tag "evil"
     end
   end
 
   describe 'render with block' do
     it 'should render slim with block' do
-      visit '/render_block_slim'
-      assert_have_selector 'h1', :content => 'prefix'
-      assert_have_selector 'h3', :content => 'postfix'
-      assert_have_selector '.slim-block'
-      assert_have_selector 'div', :content => 'go block!'
+      get "/render_block_slim"
+      assert_response_has_tag 'h1', :content => 'prefix'
+      assert_response_has_tag 'h3', :content => 'postfix'
+      assert_response_has_tag '.slim-block'
+      assert_response_has_tag 'div', :content => 'go block!'
     end
     it 'should render erb with block' do
-      visit '/render_block_erb'
-      assert_have_selector 'h1', :content => 'prefix'
-      assert_have_selector 'h3', :content => 'postfix'
-      assert_have_selector '.erb-block'
-      assert_have_selector 'div', :content => 'go block!'
+      get "/render_block_erb"
+      assert_response_has_tag 'h1', :content => 'prefix'
+      assert_response_has_tag 'h3', :content => 'postfix'
+      assert_response_has_tag '.erb-block'
+      assert_response_has_tag 'div', :content => 'go block!'
     end
     it 'should render haml with block' do
-      visit '/render_block_haml'
-      assert_have_selector 'h1', :content => 'prefix'
-      assert_have_selector 'h3', :content => 'postfix'
-      assert_have_selector '.haml-block'
-      assert_have_selector 'div', :content => 'go block!'
+      get "/render_block_haml"
+      assert_response_has_tag 'h1', :content => 'prefix'
+      assert_response_has_tag 'h3', :content => 'postfix'
+      assert_response_has_tag '.haml-block'
+      assert_response_has_tag 'div', :content => 'go block!'
     end
   end
 
   describe 'partial with block' do
     it 'should show partial slim with block' do
-      visit '/partial_block_slim'
-      assert_have_selector 'h1', :content => 'prefix'
-      assert_have_selector 'h3', :content => 'postfix'
-      assert_have_selector '.slim-block'
-      assert_have_selector 'div', :content => 'go block!'
-      assert_have_selector 'div.deep', :content => 'Done'
+      get "/partial_block_slim"
+      assert_response_has_tag 'h1', :content => 'prefix'
+      assert_response_has_tag 'h3', :content => 'postfix'
+      assert_response_has_tag '.slim-block'
+      assert_response_has_tag 'div', :content => 'go block!'
+      assert_response_has_tag 'div.deep', :content => 'Done'
     end
     it 'should show partial erb with block' do
-      visit '/partial_block_erb'
-      assert_have_selector 'h1', :content => 'prefix'
-      assert_have_selector 'h3', :content => 'postfix'
-      assert_have_selector '.erb-block'
-      assert_have_selector 'div', :content => 'go block!'
-      assert_have_selector 'div.deep', :content => 'Done'
+      get "/partial_block_erb"
+      assert_response_has_tag 'h1', :content => 'prefix'
+      assert_response_has_tag 'h3', :content => 'postfix'
+      assert_response_has_tag '.erb-block'
+      assert_response_has_tag 'div', :content => 'go block!'
+      assert_response_has_tag 'div.deep', :content => 'Done'
     end
     it 'should show partial haml with block' do
-      visit '/partial_block_haml'
-      assert_have_selector 'h1', :content => 'prefix'
-      assert_have_selector 'h3', :content => 'postfix'
-      assert_have_selector '.haml-block'
-      assert_have_selector 'div', :content => 'go block!'
-      assert_have_selector 'div.deep', :content => 'Done'
+      get "/partial_block_haml"
+      assert_response_has_tag 'h1', :content => 'prefix'
+      assert_response_has_tag 'h3', :content => 'postfix'
+      assert_response_has_tag '.haml-block'
+      assert_response_has_tag 'div', :content => 'go block!'
+      assert_response_has_tag 'div.deep', :content => 'Done'
     end
   end
 
   describe 'for #current_engine method' do
     it 'should detect correctly current engine for a padrino application' do
-      visit '/current_engine'
-      assert_have_selector 'p.start', :content => "haml"
-      assert_have_selector 'p.haml span',  :content => "haml"
-      assert_have_selector 'p.erb span',   :content => "erb"
-      assert_have_selector 'p.slim span',  :content => "slim"
-      assert_have_selector 'p.end',   :content => "haml"
+      get "/current_engine"
+      assert_response_has_tag 'p.start', :content => "haml"
+      assert_response_has_tag 'p.haml span',  :content => "haml"
+      assert_response_has_tag 'p.erb span',   :content => "erb"
+      assert_response_has_tag 'p.slim span',  :content => "slim"
+      assert_response_has_tag 'p.end',   :content => "haml"
     end
 
     it 'should detect correctly current engine for explicit engine on partials' do
-      visit '/explicit_engine'
-      assert_have_selector 'p.start', :content => "haml"
-      assert_have_selector 'p.haml span',  :content => "haml"
-      assert_have_selector 'p.erb span',   :content => "erb"
-      assert_have_selector 'p.slim span',  :content => "slim"
-      assert_have_selector 'p.end',   :content => "haml"
+      get "/explicit_engine"
+      assert_response_has_tag 'p.start', :content => "haml"
+      assert_response_has_tag 'p.haml span',  :content => "haml"
+      assert_response_has_tag 'p.erb span',   :content => "erb"
+      assert_response_has_tag 'p.slim span',  :content => "slim"
+      assert_response_has_tag 'p.end',   :content => "haml"
     end
 
     it 'should capture slim template once and only once' do
       $number_of_captures = 0
-      visit '/double_capture_slim'
+      get "/double_capture_slim"
       assert_equal 1,$number_of_captures
     end
 
     it 'should capture haml template once and only once' do
       $number_of_captures = 0
-      visit '/double_capture_haml'
+      get "/double_capture_haml"
       assert_equal 1,$number_of_captures
     end
 
     it 'should capture erb template once and only once' do
       $number_of_captures = 0
-      visit '/double_capture_erb'
+      get "/double_capture_erb"
       assert_equal 1,$number_of_captures
     end
 
     it 'should fail on wrong erb usage' do
       assert_raises(SyntaxError) do
-        visit '/wrong_capture_erb'
+        get "/wrong_capture_erb"
       end
     end
 
     it 'should ignore wrong haml usage' do
-      visit '/wrong_capture_haml'
-      assert_have_no_selector 'p', :content => 'this is wrong'
+      get "/wrong_capture_haml"
+      assert_response_has_no_tag 'p', :content => 'this is wrong'
     end
 
     it 'should ignore wrong slim usage' do
-      visit '/wrong_capture_slim'
-      assert_have_no_selector 'p', :content => 'this is wrong'
+      get "/wrong_capture_slim"
+      assert_response_has_no_tag 'p', :content => 'this is wrong'
     end
 
     it 'should support weird ruby blocks in erb' do
-      visit '/ruby_block_capture_erb'
-      assert_have_selector 'b', :content => 'c'
+      get "/ruby_block_capture_erb"
+      assert_response_has_tag 'b', :content => 'c'
     end
 
     it 'should support weird ruby blocks in haml' do
-      visit '/ruby_block_capture_haml'
-      assert_have_selector 'b', :content => 'c'
+      get "/ruby_block_capture_haml"
+      assert_response_has_tag 'b', :content => 'c'
     end
     
     it 'should support weird ruby blocks in slim' do
-      visit '/ruby_block_capture_slim'
-      assert_have_selector 'b', :content => 'c'
+      get "/ruby_block_capture_slim"
+      assert_response_has_tag 'b', :content => 'c'
     end
   end
 
-  describe 'rendering with helpers that use render' do
-    %W{erb haml slim}.each do |engine|
-      it "should work with #{engine}" do
-        skip
-        visit "/double_dive_#{engine}"
-        assert_have_selector '.outer .wrapper form .inner .core'
+  describe 'standalone partial rendering' do
+    it 'should properly render without Sinatra::Base or Padrino::Application' do
+      class Standalone
+        include Padrino::Helpers::RenderHelpers
       end
+      locals = { :user => OpenStruct.new(:name => 'Joe') }
+      result = Standalone.new.partial(File.join(File.dirname(__FILE__), 'fixtures/render_app/views/template/user'), :engine => :haml, :locals => locals)
+      assert_equal '<h1>User name is Joe</h1>', result.chomp
+    end
+
+    it 'should pass class context to renderer' do
+      class Standalone1
+        include Padrino::Helpers::RenderHelpers
+        def user
+          OpenStruct.new(:name => 'Jane')
+        end
+      end
+
+      result = Standalone1.new.partial(File.join(File.dirname(__FILE__), 'fixtures/render_app/views/template/user.haml'))
+      assert_equal '<h1>User name is Jane</h1>', result.chomp
+    end
+
+    it 'should fail on missing template' do
+      class Standalone2
+        include Padrino::Helpers::RenderHelpers
+      end
+      assert_raises RuntimeError do
+        result = Standalone2.new.partial('none')
+      end
+    end
+
+    it 'should not override existing render methods' do
+      class Standalone3
+        def render(*)
+          'existing'
+        end
+        include Padrino::Helpers::RenderHelpers
+      end
+      assert_equal 'existing', Standalone3.new.partial('none')
+    end
+
+    it 'should not add "./" to partial template name' do
+      class Standalone4
+        def render(_, file, *)
+          file.to_s
+        end
+        include Padrino::Helpers::RenderHelpers
+      end
+      assert_equal '_none', Standalone4.new.partial('none')
     end
   end
 end