require 'abstract_unit' require 'controller/fake_controllers' require 'rails/engine' class SessionTest < ActiveSupport::TestCase StubApp = lambda { |env| [200, {"Content-Type" => "text/html", "Content-Length" => "13"}, ["Hello, World!"]] } def setup @session = ActionDispatch::Integration::Session.new(StubApp) end def test_https_bang_works_and_sets_truth_by_default assert !@session.https? @session.https! assert @session.https? @session.https! false assert !@session.https? end def test_host! assert_not_equal "glu.ttono.us", @session.host @session.host! "rubyonrails.com" assert_equal "rubyonrails.com", @session.host end def test_follow_redirect_raises_when_no_redirect @session.stub :redirect?, false do assert_raise(RuntimeError) { @session.follow_redirect! } end end def test_request_via_redirect_uses_given_method path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue"} assert_called_with @session, :process, [:put, path, params: args, headers: headers] do @session.stub :redirect?, false do @session.request_via_redirect(:put, path, params: args, headers: headers) end end end def test_deprecated_request_via_redirect_uses_given_method path = "/somepath"; args = { id: '1' }; headers = { "X-Test-Header" => "testvalue" } assert_called_with @session, :process, [:put, path, params: args, headers: headers] do @session.stub :redirect?, false do assert_deprecated { @session.request_via_redirect(:put, path, args, headers) } end end end def test_request_via_redirect_follows_redirects path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue"} value_series = [true, true, false] assert_called @session, :follow_redirect!, times: 2 do @session.stub :redirect?, ->{ value_series.shift } do @session.request_via_redirect(:get, path, params: args, headers: headers) end end end def test_request_via_redirect_returns_status path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue"} @session.stub :redirect?, false do @session.stub :status, 200 do assert_equal 200, @session.request_via_redirect(:get, path, params: args, headers: headers) end end end def test_deprecated_get_via_redirect path = "/somepath"; args = { id: '1' }; headers = { "X-Test-Header" => "testvalue" } assert_called_with @session, :request_via_redirect, [:get, path, args, headers] do assert_deprecated do @session.get_via_redirect(path, args, headers) end end end def test_deprecated_post_via_redirect path = "/somepath"; args = { id: '1' }; headers = { "X-Test-Header" => "testvalue" } assert_called_with @session, :request_via_redirect, [:post, path, args, headers] do assert_deprecated do @session.post_via_redirect(path, args, headers) end end end def test_deprecated_patch_via_redirect path = "/somepath"; args = { id: '1' }; headers = { "X-Test-Header" => "testvalue" } assert_called_with @session, :request_via_redirect, [:patch, path, args, headers] do assert_deprecated do @session.patch_via_redirect(path, args, headers) end end end def test_deprecated_put_via_redirect path = "/somepath"; args = { id: '1' }; headers = { "X-Test-Header" => "testvalue" } assert_called_with @session, :request_via_redirect, [:put, path, args, headers] do assert_deprecated do @session.put_via_redirect(path, args, headers) end end end def test_deprecated_delete_via_redirect path = "/somepath"; args = { id: '1' }; headers = { "X-Test-Header" => "testvalue" } assert_called_with @session, :request_via_redirect, [:delete, path, args, headers] do assert_deprecated do @session.delete_via_redirect(path, args, headers) end end end def test_get path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:get, path, params: params, headers: headers] do @session.get(path, params: params, headers: headers) end end def test_get_with_env_and_headers path = "/index"; params = "blah"; headers = { location: 'blah' }; env = { 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest' } assert_called_with @session, :process, [:get, path, params: params, headers: headers, env: env] do @session.get(path, params: params, headers: headers, env: env) end end def test_deprecated_get path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:get, path, params: params, headers: headers] do assert_deprecated { @session.get(path, params, headers) } end end def test_post path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:post, path, params: params, headers: headers] do assert_deprecated { @session.post(path, params, headers) } end end def test_deprecated_post path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:post, path, params: params, headers: headers] do @session.post(path, params: params, headers: headers) end end def test_patch path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:patch, path, params: params, headers: headers] do @session.patch(path, params: params, headers: headers) end end def test_deprecated_patch path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:patch, path, params: params, headers: headers] do assert_deprecated { @session.patch(path, params, headers) } end end def test_put path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:put, path, params: params, headers: headers] do @session.put(path, params: params, headers: headers) end end def test_deprecated_put path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:put, path, params: params, headers: headers] do assert_deprecated { @session.put(path, params, headers) } end end def test_delete path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:delete, path, params: params, headers: headers] do assert_deprecated { @session.delete(path,params,headers) } end end def test_deprecated_delete path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:delete, path, params: params, headers: headers] do @session.delete(path, params: params, headers: headers) end end def test_head path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:head, path, params: params, headers: headers] do @session.head(path, params: params, headers: headers) end end def deprecated_test_head path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:head, path, params: params, headers: headers] do assert_deprecated { @session.head(path, params, headers) } end end def test_xml_http_request_get path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:get, path, params: params, headers: headers, xhr: true] do @session.get(path, params: params, headers: headers, xhr: true) end end def test_deprecated_xml_http_request_get path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:get, path, params: params, headers: headers, xhr: true] do @session.get(path, params: params, headers: headers, xhr: true) end end def test_deprecated_args_xml_http_request_get path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:get, path, params: params, headers: headers, xhr: true] do assert_deprecated(/xml_http_request/) { @session.xml_http_request(:get, path, params, headers) } end end def test_xml_http_request_post path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:post, path, params: params, headers: headers, xhr: true] do @session.post(path, params: params, headers: headers, xhr: true) end end def test_deprecated_xml_http_request_post path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:post, path, params: params, headers: headers, xhr: true] do @session.post(path, params: params, headers: headers, xhr: true) end end def test_deprecated_args_xml_http_request_post path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:post, path, params: params, headers: headers, xhr: true] do assert_deprecated(/xml_http_request/) { @session.xml_http_request(:post,path,params,headers) } end end def test_xml_http_request_patch path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:patch, path, params: params, headers: headers, xhr: true] do @session.patch(path, params: params, headers: headers, xhr: true) end end def test_deprecated_xml_http_request_patch path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:patch, path, params: params, headers: headers, xhr: true] do @session.patch(path, params: params, headers: headers, xhr: true) end end def test_deprecated_args_xml_http_request_patch path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:patch, path, params: params, headers: headers, xhr: true] do assert_deprecated(/xml_http_request/) { @session.xml_http_request(:patch,path,params,headers) } end end def test_xml_http_request_put path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:put, path, params: params, headers: headers, xhr: true] do @session.put(path, params: params, headers: headers, xhr: true) end end def test_deprecated_xml_http_request_put path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:put, path, params: params, headers: headers, xhr: true] do @session.put(path, params: params, headers: headers, xhr: true) end end def test_deprecated_args_xml_http_request_put path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:put, path, params: params, headers: headers, xhr: true] do assert_deprecated(/xml_http_request/) { @session.xml_http_request(:put, path, params, headers) } end end def test_xml_http_request_delete path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:delete, path, params: params, headers: headers, xhr: true] do @session.delete(path, params: params, headers: headers, xhr: true) end end def test_deprecated_xml_http_request_delete path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:delete, path, params: params, headers: headers, xhr: true] do assert_deprecated { @session.xml_http_request(:delete, path, params: params, headers: headers) } end end def test_deprecated_args_xml_http_request_delete path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:delete, path, params: params, headers: headers, xhr: true] do assert_deprecated(/xml_http_request/) { @session.xml_http_request(:delete, path, params, headers) } end end def test_xml_http_request_head path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:head, path, params: params, headers: headers, xhr: true] do @session.head(path, params: params, headers: headers, xhr: true) end end def test_deprecated_xml_http_request_head path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:head, path, params: params, headers: headers, xhr: true] do assert_deprecated(/xml_http_request/) { @session.xml_http_request(:head, path, params: params, headers: headers) } end end def test_deprecated_args_xml_http_request_head path = "/index"; params = "blah"; headers = { location: 'blah' } assert_called_with @session, :process, [:head, path, params: params, headers: headers, xhr: true] do assert_deprecated { @session.xml_http_request(:head, path, params, headers) } end end end class IntegrationTestTest < ActiveSupport::TestCase def setup @test = ::ActionDispatch::IntegrationTest.new(:app) end def test_opens_new_session session1 = @test.open_session { |sess| } session2 = @test.open_session # implicit session assert !session1.equal?(session2) end # RSpec mixes Matchers (which has a #method_missing) into # IntegrationTest's superclass. Make sure IntegrationTest does not # try to delegate these methods to the session object. def test_does_not_prevent_method_missing_passing_up_to_ancestors mixin = Module.new do def method_missing(name, *args) name.to_s == 'foo' ? 'pass' : super end end @test.class.superclass.__send__(:include, mixin) begin assert_equal 'pass', @test.foo ensure # leave other tests as unaffected as possible mixin.__send__(:remove_method, :method_missing) end end end # Tests that integration tests don't call Controller test methods for processing. # Integration tests have their own setup and teardown. class IntegrationTestUsesCorrectClass < ActionDispatch::IntegrationTest def test_integration_methods_called reset! %w( get post head patch put delete ).each do |verb| assert_nothing_raised("'#{verb}' should use integration test methods") { __send__(verb, '/') } end end end class IntegrationProcessTest < ActionDispatch::IntegrationTest class IntegrationController < ActionController::Base def get respond_to do |format| format.html { render plain: "OK", status: 200 } format.js { render plain: "JS OK", status: 200 } format.xml { render :xml => "", :status => 200 } format.rss { render :xml => "", :status => 200 } format.atom { render :xml => "", :status => 200 } end end def get_with_params render plain: "foo: #{params[:foo]}", status: 200 end def post render plain: "Created", status: 201 end def method render plain: "method: #{request.method.downcase}" end def cookie_monster cookies["cookie_1"] = nil cookies["cookie_3"] = "chocolate" render plain: "Gone", status: 410 end def set_cookie cookies["foo"] = 'bar' head :ok end def get_cookie render plain: cookies["foo"] end def redirect redirect_to action_url('get') end def remove_header response.headers.delete params[:header] head :ok, 'c' => '3' end end def test_get with_test_route_set do get '/get' assert_equal 200, status assert_equal "OK", status_message assert_response 200 assert_response :success assert_response :ok assert_equal({}, cookies.to_hash) assert_equal "OK", body assert_equal "OK", response.body assert_kind_of Nokogiri::HTML::Document, html_document assert_equal 1, request_count end end def test_get_xml_rss_atom %w[ application/xml application/rss+xml application/atom+xml ].each do |mime_string| with_test_route_set do get "/get", headers: {"HTTP_ACCEPT" => mime_string} assert_equal 200, status assert_equal "OK", status_message assert_response 200 assert_response :success assert_response :ok assert_equal({}, cookies.to_hash) assert_equal "", body assert_equal "", response.body assert_instance_of Nokogiri::XML::Document, html_document assert_equal 1, request_count end end end def test_post with_test_route_set do post '/post' assert_equal 201, status assert_equal "Created", status_message assert_response 201 assert_response :success assert_response :created assert_equal({}, cookies.to_hash) assert_equal "Created", body assert_equal "Created", response.body assert_kind_of Nokogiri::HTML::Document, html_document assert_equal 1, request_count end end test 'response cookies are added to the cookie jar for the next request' do with_test_route_set do self.cookies['cookie_1'] = "sugar" self.cookies['cookie_2'] = "oatmeal" get '/cookie_monster' assert_equal "cookie_1=; path=/\ncookie_3=chocolate; path=/", headers["Set-Cookie"] assert_equal({"cookie_1"=>"", "cookie_2"=>"oatmeal", "cookie_3"=>"chocolate"}, cookies.to_hash) end end test 'cookie persist to next request' do with_test_route_set do get '/set_cookie' assert_response :success assert_equal "foo=bar; path=/", headers["Set-Cookie"] assert_equal({"foo"=>"bar"}, cookies.to_hash) get '/get_cookie' assert_response :success assert_equal "bar", body assert_equal nil, headers["Set-Cookie"] assert_equal({"foo"=>"bar"}, cookies.to_hash) end end test 'cookie persist to next request on another domain' do with_test_route_set do host! "37s.backpack.test" get '/set_cookie' assert_response :success assert_equal "foo=bar; path=/", headers["Set-Cookie"] assert_equal({"foo"=>"bar"}, cookies.to_hash) get '/get_cookie' assert_response :success assert_equal "bar", body assert_equal nil, headers["Set-Cookie"] assert_equal({"foo"=>"bar"}, cookies.to_hash) end end def test_redirect with_test_route_set do get '/redirect' assert_equal 302, status assert_equal "Found", status_message assert_response 302 assert_response :redirect assert_response :found assert_equal "You are being redirected.", response.body assert_kind_of Nokogiri::HTML::Document, html_document assert_equal 1, request_count follow_redirect! assert_response :success assert_equal "/get", path get '/moved' assert_response :redirect assert_redirected_to '/method' end end def test_xml_http_request_get with_test_route_set do get '/get', xhr: true assert_equal 200, status assert_equal "OK", status_message assert_response 200 assert_response :success assert_response :ok assert_equal "JS OK", response.body end end def test_deprecated_xml_http_request_get with_test_route_set do assert_deprecated { xhr :get, '/get' } assert_equal 200, status assert_equal "OK", status_message assert_response 200 assert_response :success assert_response :ok assert_equal "JS OK", response.body end end def test_request_with_bad_format with_test_route_set do get '/get.php', xhr: true assert_equal 406, status assert_response 406 assert_response :not_acceptable end end def test_get_with_query_string with_test_route_set do get '/get_with_params?foo=bar' assert_equal '/get_with_params?foo=bar', request.env["REQUEST_URI"] assert_equal '/get_with_params?foo=bar', request.fullpath assert_equal "foo=bar", request.env["QUERY_STRING"] assert_equal 'foo=bar', request.query_string assert_equal 'bar', request.parameters['foo'] assert_equal 200, status assert_equal "foo: bar", response.body end end def test_get_with_parameters with_test_route_set do get '/get_with_params', params: { foo: "bar" } assert_equal '/get_with_params', request.env["PATH_INFO"] assert_equal '/get_with_params', request.path_info assert_equal 'foo=bar', request.env["QUERY_STRING"] assert_equal 'foo=bar', request.query_string assert_equal 'bar', request.parameters['foo'] assert_equal 200, status assert_equal "foo: bar", response.body end end def test_head with_test_route_set do head '/get' assert_equal 200, status assert_equal "", body head '/post' assert_equal 201, status assert_equal "", body get '/get/method' assert_equal 200, status assert_equal "method: get", body head '/get/method' assert_equal 200, status assert_equal "", body end end def test_generate_url_with_controller assert_equal 'http://www.example.com/foo', url_for(:controller => "foo") end def test_port_via_host! with_test_route_set do host! 'www.example.com:8080' get '/get' assert_equal 8080, request.port end end def test_port_via_process with_test_route_set do get 'http://www.example.com:8080/get' assert_equal 8080, request.port end end def test_https_and_port_via_host_and_https! with_test_route_set do host! 'www.example.com' https! true get '/get' assert_equal 443, request.port assert_equal true, request.ssl? host! 'www.example.com:443' https! true get '/get' assert_equal 443, request.port assert_equal true, request.ssl? host! 'www.example.com:8443' https! true get '/get' assert_equal 8443, request.port assert_equal true, request.ssl? end end def test_https_and_port_via_process with_test_route_set do get 'https://www.example.com/get' assert_equal 443, request.port assert_equal true, request.ssl? get 'https://www.example.com:8443/get' assert_equal 8443, request.port assert_equal true, request.ssl? end end def test_respect_removal_of_default_headers_by_a_controller_action with_test_route_set do with_default_headers 'a' => '1', 'b' => '2' do get '/remove_header', params: { header: 'a' } end end assert_not_includes @response.headers, 'a', 'Response should not include default header removed by the controller action' assert_includes @response.headers, 'b' assert_includes @response.headers, 'c' end private def with_default_headers(headers) original = ActionDispatch::Response.default_headers ActionDispatch::Response.default_headers = headers yield ensure ActionDispatch::Response.default_headers = original end def with_test_route_set with_routing do |set| controller = ::IntegrationProcessTest::IntegrationController.clone controller.class_eval do include set.url_helpers end set.draw do get 'moved' => redirect('/method') match ':action', :to => controller, :via => [:get, :post], :as => :action get 'get/:action', :to => controller, :as => :get_action end self.singleton_class.include(set.url_helpers) yield end end end class MetalIntegrationTest < ActionDispatch::IntegrationTest include SharedTestRoutes.url_helpers class Poller def self.call(env) if env["PATH_INFO"] =~ /^\/success/ [200, {"Content-Type" => "text/plain", "Content-Length" => "12"}, ["Hello World!"]] else [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []] end end end def setup @app = Poller end def test_successful_get get "/success" assert_response 200 assert_response :success assert_response :ok assert_equal "Hello World!", response.body end def test_failed_get get "/failure" assert_response 404 assert_response :not_found assert_equal '', response.body end def test_generate_url_without_controller assert_equal 'http://www.example.com/foo', url_for(:controller => "foo") end def test_pass_headers get "/success", headers: {"Referer" => "http://www.example.com/foo", "Host" => "http://nohost.com"} assert_equal "http://nohost.com", @request.env["HTTP_HOST"] assert_equal "http://www.example.com/foo", @request.env["HTTP_REFERER"] end def test_pass_headers_and_env get "/success", headers: { "X-Test-Header" => "value" }, env: { "HTTP_REFERER" => "http://test.com/", "HTTP_HOST" => "http://test.com" } assert_equal "http://test.com", @request.env["HTTP_HOST"] assert_equal "http://test.com/", @request.env["HTTP_REFERER"] assert_equal "value", @request.env["HTTP_X_TEST_HEADER"] end def test_pass_env get "/success", env: { "HTTP_REFERER" => "http://test.com/", "HTTP_HOST" => "http://test.com" } assert_equal "http://test.com", @request.env["HTTP_HOST"] assert_equal "http://test.com/", @request.env["HTTP_REFERER"] end def test_ignores_common_ports_in_host get "http://test.com" assert_equal "test.com", @request.env["HTTP_HOST"] get "https://test.com" assert_equal "test.com", @request.env["HTTP_HOST"] end def test_keeps_uncommon_ports_in_host get "http://test.com:123" assert_equal "test.com:123", @request.env["HTTP_HOST"] get "http://test.com:443" assert_equal "test.com:443", @request.env["HTTP_HOST"] get "https://test.com:80" assert_equal "test.com:80", @request.env["HTTP_HOST"] end end class ApplicationIntegrationTest < ActionDispatch::IntegrationTest class TestController < ActionController::Base def index render plain: "index" end end def self.call(env) routes.call(env) end def self.routes @routes ||= ActionDispatch::Routing::RouteSet.new end class MountedApp < Rails::Engine def self.routes @routes ||= ActionDispatch::Routing::RouteSet.new end routes.draw do get 'baz', :to => 'application_integration_test/test#index', :as => :baz end def self.call(*) end end routes.draw do get '', :to => 'application_integration_test/test#index', :as => :empty_string get 'foo', :to => 'application_integration_test/test#index', :as => :foo get 'bar', :to => 'application_integration_test/test#index', :as => :bar mount MountedApp => '/mounted', :as => "mounted" get 'fooz' => proc { |env| [ 200, {'X-Cascade' => 'pass'}, [ "omg" ] ] }, :anchor => false get 'fooz', :to => 'application_integration_test/test#index' end def app self.class end test "includes route helpers" do assert_equal '/', empty_string_path assert_equal '/foo', foo_path assert_equal '/bar', bar_path end test "includes mounted helpers" do assert_equal '/mounted/baz', mounted.baz_path end test "path after cascade pass" do get '/fooz' assert_equal 'index', response.body assert_equal '/fooz', path end test "route helpers after controller access" do get '/' assert_equal '/', empty_string_path get '/foo' assert_equal '/foo', foo_path get '/bar' assert_equal '/bar', bar_path end test "missing route helper before controller access" do assert_raise(NameError) { missing_path } end test "missing route helper after controller access" do get '/foo' assert_raise(NameError) { missing_path } end test "process do not modify the env passed as argument" do env = { :SERVER_NAME => 'server', 'action_dispatch.custom' => 'custom' } old_env = env.dup get '/foo', env: env assert_equal old_env, env end end class EnvironmentFilterIntegrationTest < ActionDispatch::IntegrationTest class TestController < ActionController::Base def post render plain: "Created", status: 201 end end def self.call(env) env["action_dispatch.parameter_filter"] = [:password] routes.call(env) end def self.routes @routes ||= ActionDispatch::Routing::RouteSet.new end routes.draw do match '/post', :to => 'environment_filter_integration_test/test#post', :via => :post end def app self.class end test "filters rack request form vars" do post "/post", params: { username: 'cjolly', password: 'secret' } assert_equal 'cjolly', request.filtered_parameters['username'] assert_equal '[FILTERED]', request.filtered_parameters['password'] assert_equal '[FILTERED]', request.filtered_env['rack.request.form_vars'] end end class UrlOptionsIntegrationTest < ActionDispatch::IntegrationTest class FooController < ActionController::Base def index render plain: "foo#index" end def show render plain: "foo#show" end def edit render plain: "foo#show" end end class BarController < ActionController::Base def default_url_options { :host => "bar.com" } end def index render plain: "foo#index" end end def self.routes @routes ||= ActionDispatch::Routing::RouteSet.new end def self.call(env) routes.call(env) end def app self.class end routes.draw do default_url_options :host => "foo.com" scope :module => "url_options_integration_test" do get "/foo" => "foo#index", :as => :foos get "/foo/:id" => "foo#show", :as => :foo get "/foo/:id/edit" => "foo#edit", :as => :edit_foo get "/bar" => "bar#index", :as => :bars end end test "session uses default url options from routes" do assert_equal "http://foo.com/foo", foos_url end test "current host overrides default url options from routes" do get "/foo" assert_response :success assert_equal "http://www.example.com/foo", foos_url end test "controller can override default url options from request" do get "/bar" assert_response :success assert_equal "http://bar.com/foo", foos_url end def test_can_override_default_url_options original_host = default_url_options.dup default_url_options[:host] = "foobar.com" assert_equal "http://foobar.com/foo", foos_url get "/bar" assert_response :success assert_equal "http://foobar.com/foo", foos_url ensure ActionDispatch::Integration::Session.default_url_options = self.default_url_options = original_host end test "current request path parameters are recalled" do get "/foo/1" assert_response :success assert_equal "/foo/1/edit", url_for(:action => 'edit', :only_path => true) end end class HeadWithStatusActionIntegrationTest < ActionDispatch::IntegrationTest class FooController < ActionController::Base def status head :ok end end def self.routes @routes ||= ActionDispatch::Routing::RouteSet.new end def self.call(env) routes.call(env) end def app self.class end routes.draw do get "/foo/status" => 'head_with_status_action_integration_test/foo#status' end test "get /foo/status with head result does not cause stack overflow error" do assert_nothing_raised do get '/foo/status' end assert_response :ok end end class IntegrationWithRoutingTest < ActionDispatch::IntegrationTest class FooController < ActionController::Base def index render plain: 'ok' end end def test_with_routing_resets_session klass_namespace = self.class.name.underscore with_routing do |routes| routes.draw do namespace klass_namespace do resources :foo, path: '/with' end end get '/integration_with_routing_test/with' assert_response 200 assert_equal 'ok', response.body end with_routing do |routes| routes.draw do namespace klass_namespace do resources :foo, path: '/routing' end end get '/integration_with_routing_test/routing' assert_response 200 assert_equal 'ok', response.body end end end # to work in contexts like rspec before(:all) class IntegrationRequestsWithoutSetup < ActionDispatch::IntegrationTest self._setup_callbacks = [] self._teardown_callbacks = [] class FooController < ActionController::Base def ok cookies[:key] = 'ok' render plain: 'ok' end end def test_request with_routing do |routes| routes.draw { get ':action' => FooController } get '/ok' assert_response 200 assert_equal 'ok', response.body assert_equal 'ok', cookies['key'] end end end # to ensure that session requirements in setup are persisted in the tests class IntegrationRequestsWithSessionSetup < ActionDispatch::IntegrationTest setup do cookies['user_name'] = 'david' end def test_cookies_set_in_setup_are_persisted_through_the_session get "/foo" assert_equal({"user_name"=>"david"}, cookies.to_hash) end end class IntegrationRequestEncodersTest < ActionDispatch::IntegrationTest class FooController < ActionController::Base def foos_json render json: params.permit(:foo) end def foos_wibble render plain: 'ok' end end def test_encoding_as_json post_to_foos as: :json do assert_response :success assert_match 'foos_json.json', request.path assert_equal 'application/json', request.content_type assert_equal({ 'foo' => 'fighters' }, request.request_parameters) assert_equal({ 'foo' => 'fighters' }, response.parsed_body) end end def test_encoding_as_without_mime_registration assert_raise ArgumentError do ActionDispatch::IntegrationTest.register_encoder :wibble end end def test_registering_custom_encoder Mime::Type.register 'text/wibble', :wibble ActionDispatch::IntegrationTest.register_encoder(:wibble, param_encoder: -> params { params }) post_to_foos as: :wibble do assert_response :success assert_match 'foos_wibble.wibble', request.path assert_equal 'text/wibble', request.content_type assert_equal Hash.new, request.request_parameters # Unregistered MIME Type can't be parsed. assert_equal 'ok', response.parsed_body end ensure Mime::Type.unregister :wibble end def test_parsed_body_without_as_option with_routing do |routes| routes.draw { get ':action' => FooController } get '/foos_json.json', params: { foo: 'heyo' } assert_equal({ 'foo' => 'heyo' }, response.parsed_body) end end private def post_to_foos(as:) with_routing do |routes| routes.draw { post ':action' => FooController } post "/foos_#{as}", params: { foo: 'fighters' }, as: as yield end end end