actionpack 2.2.3 → 2.3.2

data/test/controller/verification_test.rb

@@ -1,6 +1,6 @@
 require 'abstract_unit'
 
-class VerificationTest < Test::Unit::TestCase
+class VerificationTest < ActionController::TestCase
   class TestController < ActionController::Base
     verify :only => :guarded_one, :params => "one",
            :add_flash => { :error => 'unguarded' },

data/test/controller/view_paths_test.rb

@@ -1,6 +1,6 @@
 require 'abstract_unit'
 
-class ViewLoadPathsTest < Test::Unit::TestCase
+class ViewLoadPathsTest < ActionController::TestCase
   class TestController < ActionController::Base
     def self.controller_path() "test" end
     def rescue_action(e) raise end
@@ -41,31 +41,31 @@ class ViewLoadPathsTest < Test::Unit::TestCase
   def teardown
     ActiveSupport::Deprecation.behavior = @old_behavior
   end
-
+  
   def test_template_load_path_was_set_correctly
-    assert_equal [FIXTURE_LOAD_PATH], @controller.view_paths
+    assert_equal [FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
   end
 
   def test_controller_appends_view_path_correctly
     @controller.append_view_path 'foo'
-    assert_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths
+    assert_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
 
     @controller.append_view_path(%w(bar baz))
-    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths
+    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
 
     @controller.append_view_path(FIXTURE_LOAD_PATH)
-    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths
+    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
   end
 
   def test_controller_prepends_view_path_correctly
     @controller.prepend_view_path 'baz'
-    assert_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths
+    assert_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
 
     @controller.prepend_view_path(%w(foo bar))
-    assert_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths
+    assert_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
 
     @controller.prepend_view_path(FIXTURE_LOAD_PATH)
-    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths
+    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
   end
 
   def test_template_appends_view_path_correctly
@@ -73,10 +73,10 @@ class ViewLoadPathsTest < Test::Unit::TestCase
     class_view_paths = TestController.view_paths
 
     @controller.append_view_path 'foo'
-    assert_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths
+    assert_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
 
     @controller.append_view_path(%w(bar baz))
-    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths
+    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
     assert_equal class_view_paths, TestController.view_paths
   end
 
@@ -85,10 +85,10 @@ class ViewLoadPathsTest < Test::Unit::TestCase
     class_view_paths = TestController.view_paths
 
     @controller.prepend_view_path 'baz'
-    assert_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths
+    assert_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
 
     @controller.prepend_view_path(%w(foo bar))
-    assert_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths
+    assert_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
     assert_equal class_view_paths, TestController.view_paths
   end
 
@@ -130,12 +130,12 @@ class ViewLoadPathsTest < Test::Unit::TestCase
 
     A.view_paths = ['a/path']
 
-    assert_equal ['a/path'], A.view_paths
+    assert_equal ['a/path'], A.view_paths.map(&:to_s)
     assert_equal A.view_paths, B.view_paths
     assert_equal original_load_paths, C.view_paths
 
     C.view_paths = []
     assert_nothing_raised { C.view_paths << 'c/path' }
-    assert_equal ['c/path'], C.view_paths
+    assert_equal ['c/path'], C.view_paths.map(&:to_s)
   end
 end

data/test/controller/webservice_test.rb

@@ -1,19 +1,7 @@
 require 'abstract_unit'
 
-class WebServiceTest < Test::Unit::TestCase
-  class MockCGI < CGI #:nodoc:
-    attr_accessor :stdoutput, :env_table
-
-    def initialize(env, data = '')
-      self.env_table = env
-      self.stdoutput = StringIO.new
-      super(nil, StringIO.new(data))
-    end
-  end
-
+class WebServiceTest < ActionController::IntegrationTest
   class TestController < ActionController::Base
-    session :off
-
     def assign_parameters
       if params[:full]
         render :text => dump_params_keys
@@ -22,7 +10,7 @@ class WebServiceTest < Test::Unit::TestCase
       end
     end
 
-    def dump_params_keys(hash=params)
+    def dump_params_keys(hash = params)
       hash.keys.sort.inject("") do |s, k|
         value = hash[k]
         value = Hash === value ? "(#{dump_params_keys(value)})" : ""
@@ -33,7 +21,7 @@ class WebServiceTest < Test::Unit::TestCase
 
     def rescue_action(e) raise end
   end
-  
+
   def setup
     @controller = TestController.new
     @default_param_parsers = ActionController::Base.param_parsers.dup
@@ -44,186 +32,229 @@ class WebServiceTest < Test::Unit::TestCase
   end
 
   def test_check_parameters
-    process('GET')
-    assert_equal '', @controller.response.body
+    with_test_route_set do
+      get "/"
+      assert_equal '', @controller.response.body
+    end
   end
 
   def test_post_xml
-    process('POST', 'application/xml', '<entry attributed="true"><summary>content...</summary></entry>')
-    
-    assert_equal 'entry', @controller.response.body
-    assert @controller.params.has_key?(:entry)
-    assert_equal 'content...', @controller.params["entry"]['summary']
-    assert_equal 'true', @controller.params["entry"]['attributed']
+    with_test_route_set do
+      post "/", '<entry attributed="true"><summary>content...</summary></entry>',
+        {'CONTENT_TYPE' => 'application/xml'}
+
+      assert_equal 'entry', @controller.response.body
+      assert @controller.params.has_key?(:entry)
+      assert_equal 'content...', @controller.params["entry"]['summary']
+      assert_equal 'true', @controller.params["entry"]['attributed']
+    end
   end
 
   def test_put_xml
-    process('PUT', 'application/xml', '<entry attributed="true"><summary>content...</summary></entry>')
+    with_test_route_set do
+      put "/", '<entry attributed="true"><summary>content...</summary></entry>',
+        {'CONTENT_TYPE' => 'application/xml'}
 
-    assert_equal 'entry', @controller.response.body
-    assert @controller.params.has_key?(:entry)
-    assert_equal 'content...', @controller.params["entry"]['summary']
-    assert_equal 'true', @controller.params["entry"]['attributed']
+      assert_equal 'entry', @controller.response.body
+      assert @controller.params.has_key?(:entry)
+      assert_equal 'content...', @controller.params["entry"]['summary']
+      assert_equal 'true', @controller.params["entry"]['attributed']
+    end
   end
 
   def test_put_xml_using_a_type_node
-    process('PUT', 'application/xml', '<type attributed="true"><summary>content...</summary></type>')
+    with_test_route_set do
+      put "/", '<type attributed="true"><summary>content...</summary></type>',
+        {'CONTENT_TYPE' => 'application/xml'}
 
-    assert_equal 'type', @controller.response.body
-    assert @controller.params.has_key?(:type)
-    assert_equal 'content...', @controller.params["type"]['summary']
-    assert_equal 'true', @controller.params["type"]['attributed']
+      assert_equal 'type', @controller.response.body
+      assert @controller.params.has_key?(:type)
+      assert_equal 'content...', @controller.params["type"]['summary']
+      assert_equal 'true', @controller.params["type"]['attributed']
+    end
   end
 
   def test_put_xml_using_a_type_node_and_attribute
-    process('PUT', 'application/xml', '<type attributed="true"><summary type="boolean">false</summary></type>')
+    with_test_route_set do
+      put "/", '<type attributed="true"><summary type="boolean">false</summary></type>',
+        {'CONTENT_TYPE' => 'application/xml'}
 
-    assert_equal 'type', @controller.response.body
-    assert @controller.params.has_key?(:type)
-    assert_equal false, @controller.params["type"]['summary']
-    assert_equal 'true', @controller.params["type"]['attributed']
+      assert_equal 'type', @controller.response.body
+      assert @controller.params.has_key?(:type)
+      assert_equal false, @controller.params["type"]['summary']
+      assert_equal 'true', @controller.params["type"]['attributed']
+    end
   end
 
   def test_post_xml_using_a_type_node
-    process('POST', 'application/xml', '<font attributed="true"><type>arial</type></font>')
+    with_test_route_set do
+      post "/", '<font attributed="true"><type>arial</type></font>',
+        {'CONTENT_TYPE' => 'application/xml'}
 
-    assert_equal 'font', @controller.response.body
-    assert @controller.params.has_key?(:font)
-    assert_equal 'arial', @controller.params['font']['type']
-    assert_equal 'true', @controller.params["font"]['attributed']
+      assert_equal 'font', @controller.response.body
+      assert @controller.params.has_key?(:font)
+      assert_equal 'arial', @controller.params['font']['type']
+      assert_equal 'true', @controller.params["font"]['attributed']
+    end
   end
 
   def test_post_xml_using_a_root_node_named_type
-    process('POST', 'application/xml', '<type type="integer">33</type>')
+    with_test_route_set do
+      post "/", '<type type="integer">33</type>',
+        {'CONTENT_TYPE' => 'application/xml'}
 
-    assert @controller.params.has_key?(:type)
-    assert_equal 33, @controller.params['type']
+      assert @controller.params.has_key?(:type)
+      assert_equal 33, @controller.params['type']
+    end
   end
 
   def test_post_xml_using_an_attributted_node_named_type
-    ActionController::Base.param_parsers[Mime::XML] = Proc.new { |data| XmlSimple.xml_in(data, 'ForceArray' => false) }
-    process('POST', 'application/xml', '<request><type type="string">Arial,12</type><z>3</z></request>')
+    with_test_route_set do
+      ActionController::Base.param_parsers[Mime::XML] = Proc.new { |data| Hash.from_xml(data)['request'].with_indifferent_access }
+      post "/", '<request><type type="string">Arial,12</type><z>3</z></request>',
+        {'CONTENT_TYPE' => 'application/xml'}
 
-    assert_equal 'type, z', @controller.response.body
-    assert @controller.params.has_key?(:type)
-    assert_equal 'string', @controller.params['type']['type']
-    assert_equal 'Arial,12', @controller.params['type']['content']
-    assert_equal '3', @controller.params['z']
+      assert_equal 'type, z', @controller.response.body
+      assert @controller.params.has_key?(:type)
+      assert_equal 'Arial,12', @controller.params['type'], @controller.params.inspect
+      assert_equal '3', @controller.params['z'], @controller.params.inspect
+    end
   end
 
   def test_register_and_use_yaml
-    ActionController::Base.param_parsers[Mime::YAML] = Proc.new { |d| YAML.load(d) }
-    process('POST', 'application/x-yaml', {"entry" => "loaded from yaml"}.to_yaml)
-    assert_equal 'entry', @controller.response.body
-    assert @controller.params.has_key?(:entry)
-    assert_equal 'loaded from yaml', @controller.params["entry"]
+    with_test_route_set do
+      ActionController::Base.param_parsers[Mime::YAML] = Proc.new { |d| YAML.load(d) }
+      post "/", {"entry" => "loaded from yaml"}.to_yaml,
+        {'CONTENT_TYPE' => 'application/x-yaml'}
+
+      assert_equal 'entry', @controller.response.body
+      assert @controller.params.has_key?(:entry)
+      assert_equal 'loaded from yaml', @controller.params["entry"]
+    end
   end
-  
+
   def test_register_and_use_yaml_as_symbol
-    ActionController::Base.param_parsers[Mime::YAML] = :yaml
-    process('POST', 'application/x-yaml', {"entry" => "loaded from yaml"}.to_yaml)
-    assert_equal 'entry', @controller.response.body
-    assert @controller.params.has_key?(:entry)
-    assert_equal 'loaded from yaml', @controller.params["entry"]
+    with_test_route_set do
+      ActionController::Base.param_parsers[Mime::YAML] = :yaml
+      post "/", {"entry" => "loaded from yaml"}.to_yaml,
+        {'CONTENT_TYPE' => 'application/x-yaml'}
+
+      assert_equal 'entry', @controller.response.body
+      assert @controller.params.has_key?(:entry)
+      assert_equal 'loaded from yaml', @controller.params["entry"]
+    end
   end
 
   def test_register_and_use_xml_simple
-    ActionController::Base.param_parsers[Mime::XML] = Proc.new { |data| XmlSimple.xml_in(data, 'ForceArray' => false) }
-    process('POST', 'application/xml', '<request><summary>content...</summary><title>SimpleXml</title></request>' )
-    assert_equal 'summary, title', @controller.response.body
-    assert @controller.params.has_key?(:summary)
-    assert @controller.params.has_key?(:title)
-    assert_equal 'content...', @controller.params["summary"]
-    assert_equal 'SimpleXml', @controller.params["title"]
+    with_test_route_set do
+      ActionController::Base.param_parsers[Mime::XML] = Proc.new { |data| Hash.from_xml(data)['request'].with_indifferent_access }
+      post "/", '<request><summary>content...</summary><title>SimpleXml</title></request>',
+        {'CONTENT_TYPE' => 'application/xml'}
+
+      assert_equal 'summary, title', @controller.response.body
+      assert @controller.params.has_key?(:summary)
+      assert @controller.params.has_key?(:title)
+      assert_equal 'content...', @controller.params["summary"]
+      assert_equal 'SimpleXml', @controller.params["title"]
+    end
   end
 
   def test_use_xml_ximple_with_empty_request
-    ActionController::Base.param_parsers[Mime::XML] = :xml_simple
-    assert_nothing_raised { process('POST', 'application/xml', "") }
-    assert_equal "", @controller.response.body
+    with_test_route_set do
+      ActionController::Base.param_parsers[Mime::XML] = :xml_simple
+      assert_nothing_raised { post "/", "", {'CONTENT_TYPE' => 'application/xml'} }
+      assert_equal "", @controller.response.body
+    end
   end
 
   def test_dasherized_keys_as_xml
-    ActionController::Base.param_parsers[Mime::XML] = :xml_simple
-    process('POST', 'application/xml', "<first-key>\n<sub-key>...</sub-key>\n</first-key>", true)
-    assert_equal 'action, controller, first_key(sub_key), full', @controller.response.body
-    assert_equal "...", @controller.params[:first_key][:sub_key]
+    with_test_route_set do
+      ActionController::Base.param_parsers[Mime::XML] = :xml_simple
+      post "/?full=1", "<first-key>\n<sub-key>...</sub-key>\n</first-key>",
+        {'CONTENT_TYPE' => 'application/xml'}
+      assert_equal 'action, controller, first_key(sub_key), full', @controller.response.body
+      assert_equal "...", @controller.params[:first_key][:sub_key]
+    end
   end
 
   def test_typecast_as_xml
-    ActionController::Base.param_parsers[Mime::XML] = :xml_simple
-    process('POST', 'application/xml', <<-XML)
-      <data>
-        <a type="integer">15</a>
-        <b type="boolean">false</b>
-        <c type="boolean">true</c>
-        <d type="date">2005-03-17</d>
-        <e type="datetime">2005-03-17T21:41:07Z</e>
-        <f>unparsed</f>
-        <g type="integer">1</g>
-        <g>hello</g>
-        <g type="date">1974-07-25</g>
-      </data>
-    XML
-    params = @controller.params
-    assert_equal 15, params[:data][:a]
-    assert_equal false, params[:data][:b]
-    assert_equal true, params[:data][:c]
-    assert_equal Date.new(2005,3,17), params[:data][:d]
-    assert_equal Time.utc(2005,3,17,21,41,7), params[:data][:e]
-    assert_equal "unparsed", params[:data][:f]
-    assert_equal [1, "hello", Date.new(1974,7,25)], params[:data][:g]
+    with_test_route_set do
+      ActionController::Base.param_parsers[Mime::XML] = :xml_simple
+      xml = <<-XML
+        <data>
+          <a type="integer">15</a>
+          <b type="boolean">false</b>
+          <c type="boolean">true</c>
+          <d type="date">2005-03-17</d>
+          <e type="datetime">2005-03-17T21:41:07Z</e>
+          <f>unparsed</f>
+          <g type="integer">1</g>
+          <g>hello</g>
+          <g type="date">1974-07-25</g>
+        </data>
+      XML
+      post "/", xml, {'CONTENT_TYPE' => 'application/xml'}
+
+      params = @controller.params
+      assert_equal 15, params[:data][:a]
+      assert_equal false, params[:data][:b]
+      assert_equal true, params[:data][:c]
+      assert_equal Date.new(2005,3,17), params[:data][:d]
+      assert_equal Time.utc(2005,3,17,21,41,7), params[:data][:e]
+      assert_equal "unparsed", params[:data][:f]
+      assert_equal [1, "hello", Date.new(1974,7,25)], params[:data][:g]
+    end
   end
 
   def test_entities_unescaped_as_xml_simple
-    ActionController::Base.param_parsers[Mime::XML] = :xml_simple
-    process('POST', 'application/xml', <<-XML)
-      <data>&lt;foo &quot;bar&apos;s&quot; &amp; friends&gt;</data>
-    XML
-    assert_equal %(<foo "bar's" & friends>), @controller.params[:data]
+    with_test_route_set do
+      ActionController::Base.param_parsers[Mime::XML] = :xml_simple
+      xml = <<-XML
+        <data>&lt;foo &quot;bar&apos;s&quot; &amp; friends&gt;</data>
+      XML
+      post "/", xml, {'CONTENT_TYPE' => 'application/xml'}
+      assert_equal %(<foo "bar's" & friends>), @controller.params[:data]
+    end
   end
 
   def test_typecast_as_yaml
-    ActionController::Base.param_parsers[Mime::YAML] = :yaml
-    process('POST', 'application/x-yaml', <<-YAML)
-      ---
-      data:
-        a: 15
-        b: false
-        c: true
-        d: 2005-03-17
-        e: 2005-03-17T21:41:07Z
-        f: unparsed
-        g:
-          - 1
-          - hello
-          - 1974-07-25
-    YAML
-    params = @controller.params
-    assert_equal 15, params[:data][:a]
-    assert_equal false, params[:data][:b]
-    assert_equal true, params[:data][:c]
-    assert_equal Date.new(2005,3,17), params[:data][:d]
-    assert_equal Time.utc(2005,3,17,21,41,7), params[:data][:e]
-    assert_equal "unparsed", params[:data][:f]
-    assert_equal [1, "hello", Date.new(1974,7,25)], params[:data][:g]
-  end
-  
-  private  
-  
-  def process(verb, content_type = 'application/x-www-form-urlencoded', data = '', full=false)
-    
-    cgi = MockCGI.new({
-      'REQUEST_METHOD' => verb,
-      'CONTENT_TYPE'   => content_type,
-      'QUERY_STRING'   => "action=assign_parameters&controller=webservicetest/test#{"&full=1" if full}",
-      "REQUEST_URI"    => "/",
-      "HTTP_HOST"      => 'testdomain.com',
-      "CONTENT_LENGTH" => data.size,
-      "SERVER_PORT"    => "80",
-      "HTTPS"          => "off"}, data)
-          
-    @controller.send(:process, ActionController::CgiRequest.new(cgi, {}), ActionController::CgiResponse.new(cgi))
-  end
-    
+    with_test_route_set do
+      ActionController::Base.param_parsers[Mime::YAML] = :yaml
+      yaml = <<-YAML
+        ---
+        data:
+          a: 15
+          b: false
+          c: true
+          d: 2005-03-17
+          e: 2005-03-17T21:41:07Z
+          f: unparsed
+          g:
+            - 1
+            - hello
+            - 1974-07-25
+      YAML
+      post "/", yaml, {'CONTENT_TYPE' => 'application/x-yaml'}
+      params = @controller.params
+      assert_equal 15, params[:data][:a]
+      assert_equal false, params[:data][:b]
+      assert_equal true, params[:data][:c]
+      assert_equal Date.new(2005,3,17), params[:data][:d]
+      assert_equal Time.utc(2005,3,17,21,41,7), params[:data][:e]
+      assert_equal "unparsed", params[:data][:f]
+      assert_equal [1, "hello", Date.new(1974,7,25)], params[:data][:g]
+    end
+  end
+
+  private
+    def with_test_route_set
+      with_routing do |set|
+        set.draw do |map|
+          map.with_options :controller => "web_service_test/test" do |c|
+            c.connect "/", :action => "assign_parameters"
+          end
+        end
+        yield
+      end
+    end
 end