actionpack 2.1.2 → 2.2.2

data/test/template/form_tag_helper_test.rb

@@ -12,12 +12,19 @@ class FormTagHelperTest < ActionView::TestCase
     @controller = @controller.new
   end
 
+  VALID_HTML_ID = /^[A-Za-z][-_:.A-Za-z0-9]*$/ # see http://www.w3.org/TR/html4/types.html#type-name
+
   def test_check_box_tag
     actual = check_box_tag "admin"
     expected = %(<input id="admin" name="admin" type="checkbox" value="1" />)
     assert_dom_equal expected, actual
   end
 
+  def test_check_box_tag_id_sanitized
+    label_elem = root_elem(check_box_tag("project[2][admin]"))
+    assert_match VALID_HTML_ID, label_elem['id']
+  end
+
   def test_form_tag
     actual = form_tag
     expected = %(<form action="http://www.example.com" method="post">)
@@ -35,27 +42,27 @@ class FormTagHelperTest < ActionView::TestCase
     expected = %(<form action="http://www.example.com" method="post"><div style='margin:0;padding:0'><input type="hidden" name="_method" value="put" /></div>)
     assert_dom_equal expected, actual
   end
-  
+
   def test_form_tag_with_method_delete
     actual = form_tag({}, { :method => :delete })
     expected = %(<form action="http://www.example.com" method="post"><div style='margin:0;padding:0'><input type="hidden" name="_method" value="delete" /></div>)
     assert_dom_equal expected, actual
   end
 
-  def test_form_tag_with_block
-    _erbout = ''
-    form_tag("http://example.com") { _erbout.concat "Hello world!" }
+  def test_form_tag_with_block_in_erb
+    __in_erb_template = ''
+    form_tag("http://example.com") { concat "Hello world!" }
 
     expected = %(<form action="http://example.com" method="post">Hello world!</form>)
-    assert_dom_equal expected, _erbout
+    assert_dom_equal expected, output_buffer
   end
 
-  def test_form_tag_with_block_and_method
-    _erbout = ''
-    form_tag("http://example.com", :method => :put) { _erbout.concat "Hello world!" }
+  def test_form_tag_with_block_and_method_in_erb
+    __in_erb_template = ''
+    form_tag("http://example.com", :method => :put) { concat "Hello world!" }
 
     expected = %(<form action="http://example.com" method="post"><div style='margin:0;padding:0'><input type="hidden" name="_method" value="put" /></div>Hello world!</form>)
-    assert_dom_equal expected, _erbout
+    assert_dom_equal expected, output_buffer
   end
 
   def test_hidden_field_tag
@@ -64,6 +71,11 @@ class FormTagHelperTest < ActionView::TestCase
     assert_dom_equal expected, actual
   end
 
+  def test_hidden_field_tag_id_sanitized
+    input_elem = root_elem(hidden_field_tag("item[][title]"))
+    assert_match VALID_HTML_ID, input_elem['id']
+  end
+
   def test_file_field_tag
     assert_dom_equal "<input name=\"picsplz\" type=\"file\" id=\"picsplz\" />", file_field_tag("picsplz")
   end
@@ -90,11 +102,11 @@ class FormTagHelperTest < ActionView::TestCase
     actual = radio_button_tag("gender", "m") + radio_button_tag("gender", "f")
     expected = %(<input id="gender_m" name="gender" type="radio" value="m" /><input id="gender_f" name="gender" type="radio" value="f" />)
     assert_dom_equal expected, actual
-    
+
     actual = radio_button_tag("opinion", "-1") + radio_button_tag("opinion", "1")
     expected = %(<input id="opinion_-1" name="opinion" type="radio" value="-1" /><input id="opinion_1" name="opinion" type="radio" value="1" />)
     assert_dom_equal expected, actual
-    
+
     actual = radio_button_tag("person[gender]", "m")
     expected = %(<input id="person_gender_m" name="person[gender]" type="radio" value="m" />)
     assert_dom_equal expected, actual
@@ -105,19 +117,24 @@ class FormTagHelperTest < ActionView::TestCase
     expected = %(<select id="people" name="people"><option>david</option></select>)
     assert_dom_equal expected, actual
   end
-  
+
   def test_select_tag_with_multiple
     actual = select_tag "colors", "<option>Red</option><option>Blue</option><option>Green</option>", :multiple => :true
     expected = %(<select id="colors" multiple="multiple" name="colors"><option>Red</option><option>Blue</option><option>Green</option></select>)
     assert_dom_equal expected, actual
   end
-  
+
   def test_select_tag_disabled
     actual = select_tag "places", "<option>Home</option><option>Work</option><option>Pub</option>", :disabled => :true
     expected = %(<select id="places" disabled="disabled" name="places"><option>Home</option><option>Work</option><option>Pub</option></select>)
     assert_dom_equal expected, actual
   end
 
+  def test_select_tag_id_sanitized
+    input_elem = root_elem(select_tag("project[1]people", "<option>david</option>"))
+    assert_match VALID_HTML_ID, input_elem['id']
+  end
+
   def test_text_area_tag_size_string
     actual = text_area_tag "body", "hello world", "size" => "20x40"
     expected = %(<textarea cols="20" id="body" name="body" rows="40">hello world</textarea>)
@@ -147,43 +164,48 @@ class FormTagHelperTest < ActionView::TestCase
     expected = %(<input class="admin" id="title" name="title" type="text" value="Hello!" />)
     assert_dom_equal expected, actual
   end
-  
+
   def test_text_field_tag_size_symbol
     actual = text_field_tag "title", "Hello!", :size => 75
     expected = %(<input id="title" name="title" size="75" type="text" value="Hello!" />)
     assert_dom_equal expected, actual
   end
-  
+
   def test_text_field_tag_size_string
     actual = text_field_tag "title", "Hello!", "size" => "75"
     expected = %(<input id="title" name="title" size="75" type="text" value="Hello!" />)
     assert_dom_equal expected, actual
   end
-  
+
   def test_text_field_tag_maxlength_symbol
     actual = text_field_tag "title", "Hello!", :maxlength => 75
     expected = %(<input id="title" name="title" maxlength="75" type="text" value="Hello!" />)
     assert_dom_equal expected, actual
   end
-  
+
   def test_text_field_tag_maxlength_string
     actual = text_field_tag "title", "Hello!", "maxlength" => "75"
     expected = %(<input id="title" name="title" maxlength="75" type="text" value="Hello!" />)
     assert_dom_equal expected, actual
   end
-  
+
   def test_text_field_disabled
     actual = text_field_tag "title", "Hello!", :disabled => :true
     expected = %(<input id="title" name="title" disabled="disabled" type="text" value="Hello!" />)
     assert_dom_equal expected, actual
   end
-  
+
   def test_text_field_tag_with_multiple_options
     actual = text_field_tag "title", "Hello!", :size => 70, :maxlength => 80
     expected = %(<input id="title" name="title" size="70" maxlength="80" type="text" value="Hello!" />)
     assert_dom_equal expected, actual
   end
 
+  def test_text_field_tag_id_sanitized
+    input_elem = root_elem(text_field_tag("item[][title]"))
+    assert_match VALID_HTML_ID, input_elem['id']
+  end
+
   def test_label_tag_without_text
     actual = label_tag "title"
     expected = %(<label for="title">Title</label>)
@@ -208,10 +230,17 @@ class FormTagHelperTest < ActionView::TestCase
     assert_dom_equal expected, actual
   end
 
-  def test_boolean_optios
+  def test_label_tag_id_sanitized
+    label_elem = root_elem(label_tag("item[title]"))
+    assert_match VALID_HTML_ID, label_elem['for']
+  end
+
+  def test_boolean_options
     assert_dom_equal %(<input checked="checked" disabled="disabled" id="admin" name="admin" readonly="readonly" type="checkbox" value="1" />), check_box_tag("admin", 1, true, 'disabled' => true, :readonly => "yes")
     assert_dom_equal %(<input checked="checked" id="admin" name="admin" type="checkbox" value="1" />), check_box_tag("admin", 1, true, :disabled => false, :readonly => nil)
-    assert_dom_equal %(<select id="people" multiple="multiple" name="people"><option>david</option></select>), select_tag("people", "<option>david</option>", :multiple => true)
+    assert_dom_equal %(<input type="checkbox" />), tag(:input, :type => "checkbox", :checked => false)
+    assert_dom_equal %(<select id="people" multiple="multiple" name="people[]"><option>david</option></select>), select_tag("people", "<option>david</option>", :multiple => true)
+    assert_dom_equal %(<select id="people_" multiple="multiple" name="people[]"><option>david</option></select>), select_tag("people[]", "<option>david</option>", :multiple => true)
     assert_dom_equal %(<select id="people" name="people"><option>david</option></select>), select_tag("people", "<option>david</option>", :multiple => nil)
   end
 
@@ -242,31 +271,50 @@ class FormTagHelperTest < ActionView::TestCase
     )
   end
   
+  def test_image_submit_tag_with_confirmation
+    assert_dom_equal(
+      %(<input type="image" src="/images/save.gif" onclick="return confirm('Are you sure?');"/>),
+      image_submit_tag("save.gif", :confirm => "Are you sure?")
+    )
+  end
+
   def test_pass
     assert_equal 1, 1
   end
 
-  def test_field_set_tag
-    _erbout = ''
-    field_set_tag("Your details") { _erbout.concat "Hello world!" }
+  def test_field_set_tag_in_erb
+    __in_erb_template = ''
+    field_set_tag("Your details") { concat "Hello world!" }
 
     expected = %(<fieldset><legend>Your details</legend>Hello world!</fieldset>)
-    assert_dom_equal expected, _erbout
+    assert_dom_equal expected, output_buffer
 
-    _erbout = ''
-    field_set_tag { _erbout.concat "Hello world!" }
+    self.output_buffer = ''
+    field_set_tag { concat "Hello world!" }
 
     expected = %(<fieldset>Hello world!</fieldset>)
-    assert_dom_equal expected, _erbout
-    
-    _erbout = ''
-    field_set_tag('') { _erbout.concat "Hello world!" }
+    assert_dom_equal expected, output_buffer
+
+    self.output_buffer = ''
+    field_set_tag('') { concat "Hello world!" }
 
     expected = %(<fieldset>Hello world!</fieldset>)
-    assert_dom_equal expected, _erbout
+    assert_dom_equal expected, output_buffer
+
+    self.output_buffer = ''
+    field_set_tag('', :class => 'format') { concat "Hello world!" }
+
+    expected = %(<fieldset class="format">Hello world!</fieldset>)
+    assert_dom_equal expected, output_buffer
   end
 
   def protect_against_forgery?
     false
   end
+
+  private
+
+  def root_elem(rendered_content)
+    HTML::Document.new(rendered_content).root.children[0]
+  end
 end

data/test/template/javascript_helper_test.rb

@@ -3,15 +3,10 @@ require 'abstract_unit'
 class JavaScriptHelperTest < ActionView::TestCase
   tests ActionView::Helpers::JavaScriptHelper
 
-  def test_define_javascript_functions
-    assert_deprecated(/javascript_include_tag/) do
-      # check if prototype.js is included first
-      src = define_javascript_functions
-      assert_not_nil src.split("\n")[1].match(/Prototype JavaScript framework/)
-
-      # check that scriptaculous.js is not in here, only needed if loaded remotely
-      assert_nil src.split("\n")[1].match(/var Scriptaculous = \{/)
-    end
+  attr_accessor :template_format, :output_buffer
+
+  def setup
+    @template = self
   end
 
   def test_escape_javascript
@@ -51,7 +46,7 @@ class JavaScriptHelperTest < ActionView::TestCase
   end
 
   def test_link_to_function_with_href
-    assert_dom_equal %(<a href="http://example.com/" onclick="alert('Hello world!'); return false;">Greeting</a>), 
+    assert_dom_equal %(<a href="http://example.com/" onclick="alert('Hello world!'); return false;">Greeting</a>),
       link_to_function("Greeting", "alert('Hello world!')", :href => 'http://example.com/')
   end
 
@@ -85,8 +80,12 @@ class JavaScriptHelperTest < ActionView::TestCase
   end
 
   def test_javascript_tag
+    self.output_buffer = 'foo'
+
     assert_dom_equal "<script type=\"text/javascript\">\n//<![CDATA[\nalert('hello')\n//]]>\n</script>",
       javascript_tag("alert('hello')")
+
+    assert_equal 'foo', output_buffer, 'javascript_tag without a block should not concat to output_buffer'
   end
 
   def test_javascript_tag_with_options
@@ -94,16 +93,16 @@ class JavaScriptHelperTest < ActionView::TestCase
       javascript_tag("alert('hello')", :id => "the_js_tag")
   end
 
-  def test_javascript_tag_with_block
-    _erbout = ''
-    javascript_tag { _erbout.concat "alert('hello')" }
-    assert_dom_equal "<script type=\"text/javascript\">\n//<![CDATA[\nalert('hello')\n//]]>\n</script>", _erbout
+  def test_javascript_tag_with_block_in_erb
+    __in_erb_template = ''
+    javascript_tag { concat "alert('hello')" }
+    assert_dom_equal "<script type=\"text/javascript\">\n//<![CDATA[\nalert('hello')\n//]]>\n</script>", output_buffer
   end
 
-  def test_javascript_tag_with_block_and_options
-    _erbout = ''
-    javascript_tag(:id => "the_js_tag") { _erbout.concat "alert('hello')" }
-    assert_dom_equal "<script id=\"the_js_tag\" type=\"text/javascript\">\n//<![CDATA[\nalert('hello')\n//]]>\n</script>", _erbout
+  def test_javascript_tag_with_block_and_options_in_erb
+    __in_erb_template = ''
+    javascript_tag(:id => "the_js_tag") { concat "alert('hello')" }
+    assert_dom_equal "<script id=\"the_js_tag\" type=\"text/javascript\">\n//<![CDATA[\nalert('hello')\n//]]>\n</script>", output_buffer
   end
 
   def test_javascript_cdata_section

data/test/template/number_helper_i18n_test.rb

@@ -0,0 +1,54 @@
+require 'abstract_unit'
+
+class NumberHelperI18nTests < Test::Unit::TestCase
+  include ActionView::Helpers::NumberHelper
+
+  attr_reader :request
+
+  uses_mocha 'number_helper_i18n_tests' do
+    def setup
+      @number_defaults = { :precision => 3, :delimiter => ',', :separator => '.' }
+      @currency_defaults = { :unit => '$', :format => '%u%n', :precision => 2 }
+      @human_defaults = { :precision => 1 }
+      @percentage_defaults = { :delimiter => '' }
+      @precision_defaults = { :delimiter => '' }
+
+      I18n.backend.store_translations 'en', :number => { :format => @number_defaults,
+        :currency => { :format => @currency_defaults }, :human => @human_defaults }
+    end
+
+    def test_number_to_currency_translates_currency_formats
+      I18n.expects(:translate).with(:'number.format', :locale => 'en', :raise => true).returns(@number_defaults)
+      I18n.expects(:translate).with(:'number.currency.format', :locale => 'en',
+                                    :raise => true).returns(@currency_defaults)
+      number_to_currency(1, :locale => 'en')
+    end
+
+    def test_number_with_precision_translates_number_formats
+      I18n.expects(:translate).with(:'number.format', :locale => 'en', :raise => true).returns(@number_defaults)
+      I18n.expects(:translate).with(:'number.precision.format', :locale => 'en',
+                                    :raise => true).returns(@precision_defaults)
+      number_with_precision(1, :locale => 'en')
+    end
+
+    def test_number_with_delimiter_translates_number_formats
+      I18n.expects(:translate).with(:'number.format', :locale => 'en', :raise => true).returns(@number_defaults)
+      number_with_delimiter(1, :locale => 'en')
+    end
+
+    def test_number_to_percentage_translates_number_formats
+      I18n.expects(:translate).with(:'number.format', :locale => 'en', :raise => true).returns(@number_defaults)
+      I18n.expects(:translate).with(:'number.percentage.format', :locale => 'en',
+                                    :raise => true).returns(@percentage_defaults)
+      number_to_percentage(1, :locale => 'en')
+    end
+
+    def test_number_to_human_size_translates_human_formats
+      I18n.expects(:translate).with(:'number.format', :locale => 'en', :raise => true).returns(@number_defaults)
+      I18n.expects(:translate).with(:'number.human.format', :locale => 'en',
+                                    :raise => true).returns(@human_defaults)
+      # can't be called with 1 because this directly returns without calling I18n.translate
+      number_to_human_size(1025, :locale => 'en')
+    end
+  end
+end

data/test/template/number_helper_test.rb

@@ -26,7 +26,8 @@ class NumberHelperTest < ActionView::TestCase
     assert_equal("&pound;1234567890,50", number_to_currency(1234567890.50, {:unit => "&pound;", :separator => ",", :delimiter => ""}))
     assert_equal("$1,234,567,890.50", number_to_currency("1234567890.50"))
     assert_equal("1,234,567,890.50 K&#269;", number_to_currency("1234567890.50", {:unit => "K&#269;", :format => "%n %u"}))
-    assert_equal("$x.", number_to_currency("x"))
+    #assert_equal("$x.", number_to_currency("x")) # fails due to API consolidation
+    assert_equal("$x", number_to_currency("x"))
     assert_nil number_to_currency(nil)
   end
 
@@ -35,7 +36,9 @@ class NumberHelperTest < ActionView::TestCase
     assert_equal("100%", number_to_percentage(100, {:precision => 0}))
     assert_equal("302.06%", number_to_percentage(302.0574, {:precision => 2}))
     assert_equal("100.000%", number_to_percentage("100"))
+    assert_equal("1000.000%", number_to_percentage("1000"))
     assert_equal("x%", number_to_percentage("x"))
+    assert_equal("1.000,000%", number_to_percentage(1000, :delimiter => '.', :separator => ','))
     assert_nil number_to_percentage(nil)
   end
 
@@ -54,21 +57,33 @@ class NumberHelperTest < ActionView::TestCase
     assert_nil number_with_delimiter(nil)
   end
 
+  def test_number_with_delimiter_with_options_hash
+    assert_equal '12 345 678', number_with_delimiter(12345678, :delimiter => ' ')
+    assert_equal '12,345,678-05', number_with_delimiter(12345678.05, :separator => '-')
+    assert_equal '12.345.678,05', number_with_delimiter(12345678.05, :separator => ',', :delimiter => '.')
+    assert_equal '12.345.678,05', number_with_delimiter(12345678.05, :delimiter => '.', :separator => ',')
+  end
+
   def test_number_with_precision
     assert_equal("111.235", number_with_precision(111.2346))
-    assert_equal("31.83", number_with_precision(31.825, 2))    
-    assert_equal("111.23", number_with_precision(111.2346, 2))
-    assert_equal("111.00", number_with_precision(111, 2))
+    assert_equal("31.83", number_with_precision(31.825, :precision => 2))
+    assert_equal("111.23", number_with_precision(111.2346, :precision => 2))
+    assert_equal("111.00", number_with_precision(111, :precision => 2))
     assert_equal("111.235", number_with_precision("111.2346"))
-    assert_equal("31.83", number_with_precision("31.825", 2))
-    assert_equal("112", number_with_precision(111.50, 0))
-    assert_equal("1234567892", number_with_precision(1234567891.50, 0))
+    assert_equal("31.83", number_with_precision("31.825", :precision => 2))
+    assert_equal("112", number_with_precision(111.50, :precision => 0))
+    assert_equal("1234567892", number_with_precision(1234567891.50, :precision => 0))
 
     # Return non-numeric params unchanged.
     assert_equal("x", number_with_precision("x"))
     assert_nil number_with_precision(nil)
   end
 
+  def test_number_with_precision_with_custom_delimiter_and_separator
+    assert_equal '31,83',       number_with_precision(31.825, :precision => 2, :separator => ',')
+    assert_equal '1.231,83',    number_with_precision(1231.825, :precision => 2, :separator => ',', :delimiter => '.')
+  end
+
   def test_number_to_human_size
     assert_equal '0 Bytes',   number_to_human_size(0)
     assert_equal '1 Byte',    number_to_human_size(1)
@@ -80,18 +95,33 @@ class NumberHelperTest < ActionView::TestCase
     assert_equal '1.2 MB',    number_to_human_size(1234567)
     assert_equal '1.1 GB',    number_to_human_size(1234567890)
     assert_equal '1.1 TB',    number_to_human_size(1234567890123)
+    assert_equal '1025 TB',   number_to_human_size(1025.terabytes)
     assert_equal '444 KB',    number_to_human_size(444.kilobytes)
     assert_equal '1023 MB',   number_to_human_size(1023.megabytes)
     assert_equal '3 TB',      number_to_human_size(3.terabytes)
-    assert_equal '1.18 MB',   number_to_human_size(1234567, 2)
-    assert_equal '3 Bytes',   number_to_human_size(3.14159265, 4)
+    assert_equal '1.18 MB',   number_to_human_size(1234567, :precision => 2)
+    assert_equal '3 Bytes',   number_to_human_size(3.14159265, :precision => 4)
     assert_equal("123 Bytes", number_to_human_size("123"))
-    assert_equal '1.01 KB',   number_to_human_size(1.0123.kilobytes, 2)
-    assert_equal '1.01 KB',   number_to_human_size(1.0100.kilobytes, 4)
-    assert_equal '10 KB',   number_to_human_size(10.000.kilobytes, 4)
+    assert_equal '1.01 KB',   number_to_human_size(1.0123.kilobytes, :precision => 2)
+    assert_equal '1.01 KB',   number_to_human_size(1.0100.kilobytes, :precision => 4)
+    assert_equal '10 KB',   number_to_human_size(10.000.kilobytes, :precision => 4)
     assert_equal '1 Byte',   number_to_human_size(1.1)
     assert_equal '10 Bytes', number_to_human_size(10)
-    assert_nil number_to_human_size('x')
+    #assert_nil number_to_human_size('x') # fails due to API consolidation
     assert_nil number_to_human_size(nil)
   end
+
+  def test_number_to_human_size_with_options_hash
+    assert_equal '1.18 MB',   number_to_human_size(1234567, :precision => 2)
+    assert_equal '3 Bytes',   number_to_human_size(3.14159265, :precision => 4)
+    assert_equal '1.01 KB',   number_to_human_size(1.0123.kilobytes, :precision => 2)
+    assert_equal '1.01 KB',   number_to_human_size(1.0100.kilobytes, :precision => 4)
+    assert_equal '10 KB',     number_to_human_size(10.000.kilobytes, :precision => 4)
+  end
+
+  def test_number_to_human_size_with_custom_delimiter_and_separator
+    assert_equal '1,01 KB',     number_to_human_size(1.0123.kilobytes, :precision => 2, :separator => ',')
+    assert_equal '1,01 KB',     number_to_human_size(1.0100.kilobytes, :precision => 4, :separator => ',')
+    assert_equal '1.000,1 TB',  number_to_human_size(1000.1.terabytes, :delimiter => '.', :separator => ',')
+  end
 end