padrino-helpers 0.12.9 → 0.13.0.beta1

data/test/test_format_helpers.rb

@@ -57,6 +57,25 @@ 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)
@@ -139,8 +158,6 @@ 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
@@ -160,49 +177,52 @@ 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(Time.now - _DAY)
+      assert_equal '1 day', time_ago_in_words(1.day.ago)
     end
     it 'should display tomorrow' do
-      assert_equal '1 day', time_ago_in_words(Time.now + _DAY)
+      assert_equal '1 day', time_ago_in_words(1.day.from_now)
     end
     it 'should return future number of days' do
-      assert_equal '4 days', time_ago_in_words(Time.now + 4*_DAY)
+      assert_equal '4 days', time_ago_in_words(4.days.from_now)
     end
     it 'should return past days ago' do
-      assert_equal '4 days', time_ago_in_words(Time.now - 4*_DAY)
+      assert_equal '4 days', time_ago_in_words(4.days.ago)
     end
     it 'should return formatted archived date' do
-      assert_equal '3 months', time_ago_in_words(Time.now - 100*_DAY)
+      assert_equal '3 months', time_ago_in_words(100.days.ago)
     end
     it 'should return formatted archived year date' do
-      assert_equal 'over 1 year', time_ago_in_words(Time.now - 500*_DAY)
+      assert_equal 'over 1 year', time_ago_in_words(500.days.ago)
     end
     it 'should display now as a minute ago' do
-      assert_equal '1 minute', time_ago_in_words(Time.now - 60)
+      assert_equal '1 minute', time_ago_in_words(1.minute.ago)
     end
     it 'should display a few minutes ago' do
-      assert_equal '4 minutes', time_ago_in_words(Time.now - 4*60)
+      assert_equal '4 minutes', time_ago_in_words(4.minute.ago)
     end
     it 'should display an hour ago' do
-      assert_equal 'about 1 hour', time_ago_in_words(Time.now - 60*60 + 5)
+      assert_equal 'about 1 hour', time_ago_in_words(1.hour.ago + 5.minutes.ago.sec)
     end
     it 'should display a few hours ago' do
-      assert_equal 'about 3 hours', time_ago_in_words(Time.now - 3*60*60 + 5*60)
+      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)
     end
     it 'should display a few days ago' do
-      assert_equal '5 days', time_ago_in_words(Time.now - 5*_DAY - 5*60)
+      assert_equal '5 days', time_ago_in_words(5.days.ago - 5.minutes.ago.sec)
     end
     it 'should display a month ago' do
-      assert_equal 'about 1 month', time_ago_in_words(Time.now - 32*_DAY + 5*60)
+      assert_equal 'about 1 month', time_ago_in_words(32.days.ago + 5.minutes.ago.sec)
     end
     it 'should display a few months ago' do
-      assert_equal '6 months', time_ago_in_words(Time.now - 180*_DAY - 5*60)
+      assert_equal '6 months', time_ago_in_words(180.days.ago - 5.minutes.ago.sec)
     end
     it 'should display a year ago' do
-      assert_equal 'about 1 year', time_ago_in_words(Time.now - 365*_DAY - 5*60)
+      assert_equal 'about 1 year', time_ago_in_words(365.days.ago - 5.minutes.ago.sec)
     end
     it 'should display a few years ago' do
-      assert_equal 'over 7 years', time_ago_in_words(Time.now - 2800*_DAY - 5*60)
+      assert_equal 'over 7 years', time_ago_in_words(2800.days.ago - 5.minutes.ago.sec)
     end
   end
 

data/test/test_helpers.rb

@@ -7,12 +7,4 @@ 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
-      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"
+      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"
     end
 
     it 'should work for haml templates' do
-      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"
+      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"
     end
 
     it 'should work for slim templates' do
-      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"
+      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"
     end
   end # content_for
 
   describe "for #content_for? method" do
     it 'should work for erb templates' do
-      get "/erb/content_for"
-      assert_response_has_tag '.demo_has_content', :content => "true"
-      assert_response_has_tag '.fake_has_content', :content => "false"
+      visit '/erb/content_for'
+      assert_have_selector '.demo_has_content', :content => "true"
+      assert_have_selector '.fake_has_content', :content => "false"
     end
 
     it 'should work for haml templates' do
-      get "/haml/content_for"
-      assert_response_has_tag '.demo_has_content', :content => "true"
-      assert_response_has_tag '.fake_has_content', :content => "false"
+      visit '/haml/content_for'
+      assert_have_selector '.demo_has_content', :content => "true"
+      assert_have_selector '.fake_has_content', :content => "false"
     end
 
     it 'should work for slim templates' do
-      get "/slim/content_for"
-      assert_response_has_tag '.demo_has_content', :content => "true"
-      assert_response_has_tag '.fake_has_content', :content => "false"
+      visit '/slim/content_for'
+      assert_have_selector '.demo_has_content', :content => "true"
+      assert_have_selector '.fake_has_content', :content => "false"
     end
   end # content_for?
 
   describe 'for #capture_html method' do
     it 'should work for erb templates' do
-      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
+      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
     end
 
     it 'should work for haml templates' do
-      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
+      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
     end
 
     it 'should work for slim templates' do
-      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
+      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
     end
   end
 
   describe 'for #concat_content method' do
     it 'should work for erb templates' do
-      get "/erb/capture_concat"
-      assert_response_has_tag 'p', :content => "Concat Line 3", :count => 1
+      visit '/erb/capture_concat'
+      assert_have_selector 'p', :content => "Concat Line 3", :count => 1
     end
 
     it 'should work for haml templates' do
-      get "/haml/capture_concat"
-      assert_response_has_tag 'p', :content => "Concat Line 3", :count => 1
+      visit '/haml/capture_concat'
+      assert_have_selector 'p', :content => "Concat Line 3", :count => 1
     end
 
     it 'should work for slim templates' do
-      get "/slim/capture_concat"
-      assert_response_has_tag 'p', :content => "Concat Line 3", :count => 1
+      visit '/slim/capture_concat'
+      assert_have_selector 'p', :content => "Concat Line 3", :count => 1
     end
   end
 
   describe 'for #block_is_template?' do
     it 'should work for erb templates' do
-      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
+      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
     end
 
     it 'should work for haml templates' do
-      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
+      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
     end
 
     it 'should work for slim templates' do
-      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
+      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
     end
   end
 
   describe 'for #current_engine method' do
     it 'should detect correctly current engine for erb' do
-      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"
+      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"
     end
 
     it 'should detect correctly current engine for haml' do
-      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"
+      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"
     end
 
     it 'should detect correctly current engine for slim' do
-      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"
+      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"
     end
   end
 
   describe 'for #partial method in simple sinatra application' do
     it 'should properly output in erb' do
-      get "/erb/simple_partial"
-      assert_response_has_tag 'p.erb',  :content => "erb"
+      visit '/erb/simple_partial'
+      assert_have_selector 'p.erb',  :content => "erb"
     end
 
     it 'should properly output in haml' do
-      get "/haml/simple_partial"
-      assert_response_has_tag 'p.haml',  :content => "haml"
+      visit '/haml/simple_partial'
+      assert_have_selector 'p.haml',  :content => "haml"
     end
 
     it 'should properly output in slim' do
-      get "/slim/simple_partial"
-      assert_response_has_tag 'p.slim',  :content => "slim"
+      visit '/slim/simple_partial'
+      assert_have_selector 'p.slim',  :content => "slim"
     end
   end
 end

data/test/test_render_helpers.rb

@@ -7,261 +7,219 @@ describe "RenderHelpers" do
   end
 
   describe 'for #partial method and object' do
-    before { get "/partial/object" }
+    before { visit '/partial/object' }
     it 'should render partial html with object' do
-      assert_response_has_tag "h1", :content => "User name is John"
+      assert_have_selector "h1", :content => "User name is John"
     end
     it 'should have no counter index for single item' do
-      assert_response_has_no_tag "p", :content => "My counter is 1", :count => 1
+      assert_have_no_selector "p", :content => "My counter is 1", :count => 1
     end
     it 'should include extra locals information' do
-      assert_response_has_tag 'p', :content => "Extra is bar"
+      assert_have_selector 'p', :content => "Extra is bar"
     end
   end
 
   describe 'for #partial method and collection' do
-    before { get "/partial/collection" }
+    before { visit '/partial/collection' }
     it 'should render partial html with collection' do
-      assert_response_has_tag "h1", :content => "User name is John"
-      assert_response_has_tag "h1", :content => "User name is Billy"
+      assert_have_selector "h1", :content => "User name is John"
+      assert_have_selector "h1", :content => "User name is Billy"
     end
     it 'should include counter which contains item index' do
-      assert_response_has_tag "p", :content => "My counter is 1"
-      assert_response_has_tag "p", :content => "My counter is 2"
+      assert_have_selector "p", :content => "My counter is 1"
+      assert_have_selector "p", :content => "My counter is 2"
     end
     it 'should include extra locals information' do
-      assert_response_has_tag 'p', :content => "Extra is bar"
+      assert_have_selector 'p', :content => "Extra is bar"
     end
   end
 
   describe 'for #partial with ext and collection' do
-    before { get "/partial/collection.ext" }
+    before { visit '/partial/collection.ext' }
     it 'should not fail horribly with `invalid locals key` RuntimeError' do
-      assert_response_has_tag "h1", :content => "User name is John"
+      assert_have_selector "h1", :content => "User name is John"
     end
   end
 
   describe 'for #partial method and locals' do
-    before { get "/partial/locals" }
+    before { visit '/partial/locals' }
     it 'should render partial html with locals' do
-      assert_response_has_tag "h1", :content => "User name is John"
+      assert_have_selector "h1", :content => "User name is John"
     end
     it 'should have no counter index for single item' do
-      assert_response_has_no_tag "p", :content => "My counter is 1", :count => 1
+      assert_have_no_selector "p", :content => "My counter is 1", :count => 1
     end
     it 'should include extra locals information' do
-      assert_response_has_tag 'p', :content => "Extra is bar"
+      assert_have_selector 'p', :content => "Extra is bar"
     end
   end
 
   describe 'for #partial method taking a path starting with forward slash' do
-    before { get "/partial/foward_slash" }
+    before { visit '/partial/foward_slash' }
     it 'should render partial without throwing an error' do
-      assert_response_has_tag "h1", :content => "User name is John"
+      assert_have_selector "h1", :content => "User name is John"
     end
   end
 
   describe 'for #partial method with unsafe engine' do
     it 'should render partial without escaping it' do
-      get "/partial/unsafe"
-      assert_response_has_tag "h1", :content => "User name is John"
+      visit '/partial/unsafe'
+      assert_have_selector "h1", :content => "User name is John"
     end
     it 'should render partial object without escaping it' do
-      get "/partial/unsafe_one"
-      assert_response_has_tag "h1", :content => "User name is Mary"
+      visit '/partial/unsafe_one'
+      assert_have_selector "h1", :content => "User name is Mary"
     end
     it 'should render partial collection without escaping it' do
-      get "/partial/unsafe_many"
-      assert_response_has_tag "h1", :content => "User name is John"
-      assert_response_has_tag "h1", :content => "User name is Mary"
+      visit '/partial/unsafe_many'
+      assert_have_selector "h1", :content => "User name is John"
+      assert_have_selector "h1", :content => "User name is Mary"
     end
     it 'should render unsafe partial without escaping it' do
-      get "/partial/unsafe?block=%3Cevil%3E"
-      assert_response_has_tag "h1", :content => "User name is John"
-      assert_response_has_tag "evil"
+      visit '/partial/unsafe?block=%3Cevil%3E'
+      assert_have_selector "h1", :content => "User name is John"
+      assert_have_selector "evil"
     end
     it 'should render unsafe partial object without escaping it' do
-      get "/partial/unsafe_one?block=%3Cevil%3E"
-      assert_response_has_tag "h1", :content => "User name is Mary"
-      assert_response_has_tag "evil"
+      visit '/partial/unsafe_one?block=%3Cevil%3E'
+      assert_have_selector "h1", :content => "User name is Mary"
+      assert_have_selector "evil"
     end
     it 'should render unsafe partial collection without escaping it' do
-      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"
+      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"
     end
   end
 
   describe 'render with block' do
     it 'should render slim with block' do
-      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!'
+      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!'
     end
     it 'should render erb with block' do
-      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!'
+      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!'
     end
     it 'should render haml with block' do
-      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!'
+      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!'
     end
   end
 
   describe 'partial with block' do
     it 'should show partial slim with block' do
-      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'
+      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'
     end
     it 'should show partial erb with block' do
-      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'
+      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'
     end
     it 'should show partial haml with block' do
-      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'
+      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'
     end
   end
 
   describe 'for #current_engine method' do
     it 'should detect correctly current engine for a padrino application' do
-      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"
+      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"
     end
 
     it 'should detect correctly current engine for explicit engine on partials' do
-      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"
+      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"
     end
 
     it 'should capture slim template once and only once' do
       $number_of_captures = 0
-      get "/double_capture_slim"
+      visit '/double_capture_slim'
       assert_equal 1,$number_of_captures
     end
 
     it 'should capture haml template once and only once' do
       $number_of_captures = 0
-      get "/double_capture_haml"
+      visit '/double_capture_haml'
       assert_equal 1,$number_of_captures
     end
 
     it 'should capture erb template once and only once' do
       $number_of_captures = 0
-      get "/double_capture_erb"
+      visit '/double_capture_erb'
       assert_equal 1,$number_of_captures
     end
 
     it 'should fail on wrong erb usage' do
       assert_raises(SyntaxError) do
-        get "/wrong_capture_erb"
+        visit '/wrong_capture_erb'
       end
     end
 
     it 'should ignore wrong haml usage' do
-      get "/wrong_capture_haml"
-      assert_response_has_no_tag 'p', :content => 'this is wrong'
+      visit '/wrong_capture_haml'
+      assert_have_no_selector 'p', :content => 'this is wrong'
     end
 
     it 'should ignore wrong slim usage' do
-      get "/wrong_capture_slim"
-      assert_response_has_no_tag 'p', :content => 'this is wrong'
+      visit '/wrong_capture_slim'
+      assert_have_no_selector 'p', :content => 'this is wrong'
     end
 
     it 'should support weird ruby blocks in erb' do
-      get "/ruby_block_capture_erb"
-      assert_response_has_tag 'b', :content => 'c'
+      visit '/ruby_block_capture_erb'
+      assert_have_selector 'b', :content => 'c'
     end
 
     it 'should support weird ruby blocks in haml' do
-      get "/ruby_block_capture_haml"
-      assert_response_has_tag 'b', :content => 'c'
+      visit '/ruby_block_capture_haml'
+      assert_have_selector 'b', :content => 'c'
     end
     
     it 'should support weird ruby blocks in slim' do
-      get "/ruby_block_capture_slim"
-      assert_response_has_tag 'b', :content => 'c'
+      visit '/ruby_block_capture_slim'
+      assert_have_selector 'b', :content => 'c'
     end
   end
 
-  describe 'standalone partial rendering' do
-    it 'should properly render without Sinatra::Base or Padrino::Application' do
-      class Standalone
-        include Padrino::Helpers::RenderHelpers
+  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'
       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