jro_apps/redmine Commit - r15284:6cc6a918b4f3

Pass parameters with :params in controller tests....

Jean-Philippe Lang -

r15284:6cc6a918b4f3

parent child

Context file:

r15284:6cc6a918b4f3

Collapse all files

test/functional/roles_controller_test.rb +55 -35

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class RolesControllerTest < Redmine::ControllerTest
               fixtures :roles, :users, :members, :member_roles, :workflows, :trackers
               def setup
                 User.current = nil
                 @request.session[:user_id] = 1 # admin
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:roles)
                 assert_equal Role.order('builtin, position').to_a, assigns(:roles)
                 assert_select 'a[href="/roles/1/edit"]', :text => 'Manager'
               end
               def test_new
                 get :new
                 assert_response :success
                 assert_template 'new'
               end
               def test_new_with_copy
                 copy_from = Role.find(2)
-                get :new, :copy => copy_from.id.to_s
+                get :new, :params => {:copy => copy_from.id.to_s}
                 assert_response :success
                 assert_template 'new'
                 role = assigns(:role)
                 assert_equal copy_from.permissions, role.permissions
                 assert_select 'form' do
                   # blank name
                   assert_select 'input[name=?][value=""]', 'role[name]'
                   # edit_project permission checked
                   assert_select 'input[type=checkbox][name=?][value=edit_project][checked=checked]', 'role[permissions][]'
                   # add_project permission not checked
                   assert_select 'input[type=checkbox][name=?][value=add_project]', 'role[permissions][]'
                   assert_select 'input[type=checkbox][name=?][value=add_project][checked=checked]', 'role[permissions][]', 0
                   # workflow copy selected
                   assert_select 'select[name=?]', 'copy_workflow_from' do
                     assert_select 'option[value="2"][selected=selected]'
                   end
                 end
               end
               def test_create_with_validaton_failure
-                post :create, :role => {:name => '',
+                post :create, :params => {
-                                     :permissions => ['add_issues', 'edit_issues', 'log_time', ''],
+                  :role => {
-                                     :assignable => '0'}
+                    :name => '',
+                    :permissions => ['add_issues', 'edit_issues', 'log_time', ''],
+                    :assignable => '0'
+                  }
+                }
                 assert_response :success
                 assert_template 'new'
                 assert_select 'div#errorExplanation'
               end
               def test_create_without_workflow_copy
-                post :create, :role => {:name => 'RoleWithoutWorkflowCopy',
+                post :create, :params => {
-                                     :permissions => ['add_issues', 'edit_issues', 'log_time', ''],
+                  :role => {
-                                     :assignable => '0'}
+                    :name => 'RoleWithoutWorkflowCopy',
+                    :permissions => ['add_issues', 'edit_issues', 'log_time', ''],
+                    :assignable => '0'
+                  }
+                }
                 assert_redirected_to '/roles'
                 role = Role.find_by_name('RoleWithoutWorkflowCopy')
                 assert_not_nil role
                 assert_equal [:add_issues, :edit_issues, :log_time], role.permissions
                 assert !role.assignable?
               end
               def test_create_with_workflow_copy
-                post :create, :role => {:name => 'RoleWithWorkflowCopy',
+                post :create, :params => {
-                                     :permissions => ['add_issues', 'edit_issues', 'log_time', ''],
+                  :role => {
-                                     :assignable => '0'},
+                    :name => 'RoleWithWorkflowCopy',
-                           :copy_workflow_from => '1'
+                    :permissions => ['add_issues', 'edit_issues', 'log_time', ''],
+                    :assignable => '0'
+                  },
+                  :copy_workflow_from => '1'
+                }
                 assert_redirected_to '/roles'
                 role = Role.find_by_name('RoleWithWorkflowCopy')
                 assert_not_nil role
                 assert_equal Role.find(1).workflow_rules.size, role.workflow_rules.size
               end
               def test_edit
-                get :edit, :id => 1
+                get :edit, :params => {:id => 1}
                 assert_response :success
                 assert_template 'edit'
                 assert_equal Role.find(1), assigns(:role)
                 assert_select 'select[name=?]', 'role[issues_visibility]'
               end
               def test_edit_anonymous
-                get :edit, :id => Role.anonymous.id
+                get :edit, :params => {:id => Role.anonymous.id}
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'select[name=?]', 'role[issues_visibility]', 0
               end
               def test_edit_invalid_should_respond_with_404
-                get :edit, :id => 999
+                get :edit, :params => {:id => 999}
                 assert_response 404
               end
               def test_update
-                put :update, :id => 1,
+                put :update, :params => {
-                            :role => {:name => 'Manager',
+                  :id => 1,
-                                      :permissions => ['edit_project', ''],
+                  :role => {
-                                      :assignable => '0'}
+                    :name => 'Manager',
+                    :permissions => ['edit_project', ''],
+                    :assignable => '0'
+                  }
+                }
                 assert_redirected_to '/roles'
                 role = Role.find(1)
                 assert_equal [:edit_project], role.permissions
               end
               def test_update_trackers_permissions
-                put :update, :id => 1, :role => {
+                put :update, :params => {
-                  :permissions_all_trackers => {'add_issues' => '0'},
+                  :id => 1,
-                  :permissions_tracker_ids => {'add_issues' => ['1', '3', '']}
+                  :role => {
+                    :permissions_all_trackers => {'add_issues' => '0'},
+                    :permissions_tracker_ids => {'add_issues' => ['1', '3', '']}
+                  }
                 }
                 assert_redirected_to '/roles'
                 role = Role.find(1)
                 assert_equal({'add_issues' => '0'}, role.permissions_all_trackers)
                 assert_equal({'add_issues' => ['1', '3']}, role.permissions_tracker_ids)
                 assert_equal false, role.permissions_all_trackers?(:add_issues)
                 assert_equal [1, 3], role.permissions_tracker_ids(:add_issues).sort
               end
               def test_update_with_failure
-                put :update, :id => 1, :role => {:name => ''}
+                put :update, :params => {:id => 1, :role => {:name => ''}}
                 assert_response :success
                 assert_template 'edit'
               end
               def test_destroy
                 r = Role.create!(:name => 'ToBeDestroyed', :permissions => [:view_wiki_pages])
-                delete :destroy, :id => r
+                delete :destroy, :params => {:id => r}
                 assert_redirected_to '/roles'
                 assert_nil Role.find_by_id(r.id)
               end
               def test_destroy_role_in_use
-                delete :destroy, :id => 1
+                delete :destroy, :params => {:id => 1}
                 assert_redirected_to '/roles'
                 assert_equal 'This role is in use and cannot be deleted.', flash[:error]
                 assert_not_nil Role.find_by_id(1)
               end
               def test_get_permissions
                 get :permissions
                 assert_response :success
                 assert_template 'permissions'
                 assert_not_nil assigns(:roles)
                 assert_equal Role.order('builtin, position').to_a, assigns(:roles)
                 assert_select 'input[name=?][type=checkbox][value=add_issues][checked=checked]', 'permissions[3][]'
                 assert_select 'input[name=?][type=checkbox][value=delete_issues]:not([checked])', 'permissions[3][]'
               end
               def test_post_permissions
-                post :permissions, :permissions => { '0' => '', '1' => ['edit_issues'], '3' => ['add_issues', 'delete_issues']}
+                post :permissions, :params => {
+                  :permissions => {
+                    '0' => '',
+                    '1' => ['edit_issues'],
+                    '3' => ['add_issues', 'delete_issues']
+                  }
+                }
                 assert_redirected_to '/roles'
                 assert_equal [:edit_issues], Role.find(1).permissions
                 assert_equal [:add_issues, :delete_issues], Role.find(3).permissions
                 assert Role.find(2).permissions.empty?
               end
               def test_clear_all_permissions
-                post :permissions, :permissions => { '0' => '' }
+                post :permissions, :params => {:permissions => { '0' => '' }}
                 assert_redirected_to '/roles'
                 assert Role.find(1).permissions.empty?
               end
               def test_move_highest
-                put :update, :id => 3, :role => {:position => 1}
+                put :update, :params => {:id => 3, :role => {:position => 1}}
                 assert_redirected_to '/roles'
                 assert_equal 1, Role.find(3).position
               end
               def test_move_higher
                 position = Role.find(3).position
-                put :update, :id => 3, :role => {:position => position - 1}
+                put :update, :params => {:id => 3, :role => {:position => position - 1}}
                 assert_redirected_to '/roles'
                 assert_equal position - 1, Role.find(3).position
               end
               def test_move_lower
                 position = Role.find(2).position
-                put :update, :id => 2, :role => {:position => position + 1}
+                put :update, :params => {:id => 2, :role => {:position => position + 1}}
                 assert_redirected_to '/roles'
                 assert_equal position + 1, Role.find(2).position
               end
               def test_move_lowest
-                put :update, :id => 2, :role => {:position => Role.givable.count}
+                put :update, :params => {:id => 2, :role => {:position => Role.givable.count}}
                 assert_redirected_to '/roles'
                 assert_equal Role.givable.count, Role.find(2).position
               end
             end

test/functional/search_controller_test.rb +39 -38

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class SearchControllerTest < Redmine::ControllerTest
               fixtures :projects, :projects_trackers,
                        :enabled_modules, :roles, :users, :members, :member_roles,
                        :issues, :trackers, :issue_statuses, :enumerations,
                        :workflows,
                        :custom_fields, :custom_values,
                        :custom_fields_projects, :custom_fields_trackers,
                        :repositories, :changesets
               def setup
                 User.current = nil
               end
               def test_search_for_projects
                 get :index
                 assert_response :success
                 assert_template 'index'
-                get :index, :q => "cook"
+                get :index, :params => {:q => "cook"}
                 assert_response :success
                 assert_template 'index'
                 assert assigns(:results).include?(Project.find(1))
               end
               def test_search_on_archived_project_should_return_404
                 Project.find(3).archive
-                get :index, :id => 3
+                get :index, :params => {:id => 3}
                 assert_response 404
               end
               def test_search_on_invisible_project_by_user_should_be_denied
                 @request.session[:user_id] = 7
-                get :index, :id => 2
+                get :index, :params => {:id => 2}
                 assert_response 403
               end
               def test_search_on_invisible_project_by_anonymous_user_should_redirect
-                get :index, :id => 2
+                get :index, :params => {:id => 2}
                 assert_response 302
               end
               def test_search_on_private_project_by_member_should_succeed
                 @request.session[:user_id] = 2
-                get :index, :id => 2
+                get :index, :params => {:id => 2}
                 assert_response :success
               end
               def test_search_all_projects
                 with_settings :default_language => 'en' do
-                  get :index, :q => 'recipe subproject commit', :all_words => ''
+                  get :index, :params => {:q => 'recipe subproject commit', :all_words => ''}
                 end
                 assert_response :success
                 assert_template 'index'
                 assert assigns(:results).include?(Issue.find(2))
                 assert assigns(:results).include?(Issue.find(5))
                 assert assigns(:results).include?(Changeset.find(101))
                 assert_select 'dt.issue a', :text => /Add ingredients categories/
                 assert_select 'dd', :text => /should be classified by categories/
                 assert assigns(:result_count_by_type).is_a?(Hash)
                 assert_equal 5, assigns(:result_count_by_type)['changesets']
                 assert_select 'a', :text => 'Changesets (5)'
               end
               def test_search_issues
-                get :index, :q => 'issue', :issues => 1
+                get :index, :params => {:q => 'issue', :issues => 1}
                 assert_response :success
                 assert_template 'index'
                 assert_equal true, assigns(:all_words)
                 assert_equal false, assigns(:titles_only)
                 assert assigns(:results).include?(Issue.find(8))
                 assert assigns(:results).include?(Issue.find(5))
                 assert_select 'dt.issue.closed a',  :text => /Closed/
               end
               def test_search_issues_should_search_notes
                 Journal.create!(:journalized => Issue.find(2), :notes => 'Issue notes with searchkeyword')
-                get :index, :q => 'searchkeyword', :issues => 1
+                get :index, :params => {:q => 'searchkeyword', :issues => 1}
                 assert_response :success
                 assert_include Issue.find(2), assigns(:results)
               end
               def test_search_issues_with_multiple_matches_in_journals_should_return_issue_once
                 Journal.create!(:journalized => Issue.find(2), :notes => 'Issue notes with searchkeyword')
                 Journal.create!(:journalized => Issue.find(2), :notes => 'Issue notes with searchkeyword')
-                get :index, :q => 'searchkeyword', :issues => 1
+                get :index, :params => {:q => 'searchkeyword', :issues => 1}
                 assert_response :success
                 assert_include Issue.find(2), assigns(:results)
                 assert_equal 1, assigns(:results).size
               end
               def test_search_issues_should_search_private_notes_with_permission_only
                 Journal.create!(:journalized => Issue.find(2), :notes => 'Private notes with searchkeyword', :private_notes => true)
                 @request.session[:user_id] = 2
                 Role.find(1).add_permission! :view_private_notes
-                get :index, :q => 'searchkeyword', :issues => 1
+                get :index, :params => {:q => 'searchkeyword', :issues => 1}
                 assert_response :success
                 assert_include Issue.find(2), assigns(:results)
                 Role.find(1).remove_permission! :view_private_notes
-                get :index, :q => 'searchkeyword', :issues => 1
+                get :index, :params => {:q => 'searchkeyword', :issues => 1}
                 assert_response :success
                 assert_not_include Issue.find(2), assigns(:results)
               end
               def test_search_all_projects_with_scope_param
-                get :index, :q => 'issue', :scope => 'all'
+                get :index, :params => {:q => 'issue', :scope => 'all'}
                 assert_response :success
                 assert_template 'index'
                 assert assigns(:results).present?
               end
               def test_search_my_projects
                 @request.session[:user_id] = 2
-                get :index, :id => 1, :q => 'recipe subproject', :scope => 'my_projects', :all_words => ''
+                get :index, :params => {:id => 1, :q => 'recipe subproject', :scope => 'my_projects', :all_words => ''}
                 assert_response :success
                 assert_template 'index'
                 assert assigns(:results).include?(Issue.find(1))
                 assert !assigns(:results).include?(Issue.find(5))
               end
               def test_search_my_projects_without_memberships
                 # anonymous user has no memberships
-                get :index, :id => 1, :q => 'recipe subproject', :scope => 'my_projects', :all_words => ''
+                get :index, :params => {:id => 1, :q => 'recipe subproject', :scope => 'my_projects', :all_words => ''}
                 assert_response :success
                 assert_template 'index'
                 assert assigns(:results).empty?
               end
               def test_search_project_and_subprojects
-                get :index, :id => 1, :q => 'recipe subproject', :scope => 'subprojects', :all_words => ''
+                get :index, :params => {:id => 1, :q => 'recipe subproject', :scope => 'subprojects', :all_words => ''}
                 assert_response :success
                 assert_template 'index'
                 assert assigns(:results).include?(Issue.find(1))
                 assert assigns(:results).include?(Issue.find(5))
               end
               def test_search_without_searchable_custom_fields
                 CustomField.update_all "searchable = #{ActiveRecord::Base.connection.quoted_false}"
-                get :index, :id => 1
+                get :index, :params => {:id => 1}
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:project)
-                get :index, :id => 1, :q => "can"
+                get :index, :params => {:id => 1, :q => "can"}
                 assert_response :success
                 assert_template 'index'
               end
               def test_search_with_searchable_custom_fields
-                get :index, :id => 1, :q => "stringforcustomfield"
+                get :index, :params => {:id => 1, :q => "stringforcustomfield"}
                 assert_response :success
                 results = assigns(:results)
                 assert_not_nil results
                 assert_equal 1, results.size
                 assert results.include?(Issue.find(7))
               end
               def test_search_without_attachments
                 issue = Issue.generate! :subject => 'search_attachments'
                 attachment = Attachment.generate! :container => Issue.find(1), :filename => 'search_attachments.patch'
-                get :index, :id => 1, :q => 'search_attachments', :attachments => '0'
+                get :index, :params => {:id => 1, :q => 'search_attachments', :attachments => '0'}
                 results = assigns(:results)
                 assert_equal 1, results.size
                 assert_equal issue, results.first
               end
               def test_search_attachments_only
                 issue = Issue.generate! :subject => 'search_attachments'
                 attachment = Attachment.generate! :container => Issue.find(1), :filename => 'search_attachments.patch'
-                get :index, :id => 1, :q => 'search_attachments', :attachments => 'only'
+                get :index, :params => {:id => 1, :q => 'search_attachments', :attachments => 'only'}
                 results = assigns(:results)
                 assert_equal 1, results.size
                 assert_equal attachment.container, results.first
               end
               def test_search_with_attachments
                 Issue.generate! :subject => 'search_attachments'
                 Attachment.generate! :container => Issue.find(1), :filename => 'search_attachments.patch'
-                get :index, :id => 1, :q => 'search_attachments', :attachments => '1'
+                get :index, :params => {:id => 1, :q => 'search_attachments', :attachments => '1'}
                 results = assigns(:results)
                 assert_equal 2, results.size
               end
               def test_search_open_issues
                 Issue.generate! :subject => 'search_open'
                 Issue.generate! :subject => 'search_open', :status_id => 5
-                get :index, :id => 1, :q => 'search_open', :open_issues => '1'
+                get :index, :params => {:id => 1, :q => 'search_open', :open_issues => '1'}
                 results = assigns(:results)
                 assert_equal 1, results.size
               end
               def test_search_all_words
                 # 'all words' is on by default
-                get :index, :id => 1, :q => 'recipe updating saving', :all_words => '1'
+                get :index, :params => {:id => 1, :q => 'recipe updating saving', :all_words => '1'}
                 assert_equal true, assigns(:all_words)
                 results = assigns(:results)
                 assert_not_nil results
                 assert_equal 1, results.size
                 assert results.include?(Issue.find(3))
               end
               def test_search_one_of_the_words
-                get :index, :id => 1, :q => 'recipe updating saving', :all_words => ''
+                get :index, :params => {:id => 1, :q => 'recipe updating saving', :all_words => ''}
                 assert_equal false, assigns(:all_words)
                 results = assigns(:results)
                 assert_not_nil results
                 assert_equal 3, results.size
                 assert results.include?(Issue.find(3))
               end
               def test_search_titles_only_without_result
-                get :index, :id => 1, :q => 'recipe updating saving', :titles_only => '1'
+                get :index, :params => {:id => 1, :q => 'recipe updating saving', :titles_only => '1'}
                 results = assigns(:results)
                 assert_not_nil results
                 assert_equal 0, results.size
               end
               def test_search_titles_only
-                get :index, :id => 1, :q => 'recipe', :titles_only => '1'
+                get :index, :params => {:id => 1, :q => 'recipe', :titles_only => '1'}
                 assert_equal true, assigns(:titles_only)
                 results = assigns(:results)
                 assert_not_nil results
                 assert_equal 2, results.size
               end
               def test_search_content
                 Issue.where(:id => 1).update_all("description = 'This is a searchkeywordinthecontent'")
-                get :index, :id => 1, :q => 'searchkeywordinthecontent', :titles_only => ''
+                get :index, :params => {:id => 1, :q => 'searchkeywordinthecontent', :titles_only => ''}
                 assert_equal false, assigns(:titles_only)
                 results = assigns(:results)
                 assert_not_nil results
                 assert_equal 1, results.size
               end
               def test_search_with_pagination
                 issue = (0..24).map {Issue.generate! :subject => 'search_with_limited_results'}.reverse
-                get :index, :q => 'search_with_limited_results'
+                get :index, :params => {:q => 'search_with_limited_results'}
                 assert_response :success
                 assert_equal issue[0..9], assigns(:results)
-                get :index, :q => 'search_with_limited_results', :page => 2
+                get :index, :params => {:q => 'search_with_limited_results', :page => 2}
                 assert_response :success
                 assert_equal issue[10..19], assigns(:results)
-                get :index, :q => 'search_with_limited_results', :page => 3
+                get :index, :params => {:q => 'search_with_limited_results', :page => 3}
                 assert_response :success
                 assert_equal issue[20..24], assigns(:results)
-                get :index, :q => 'search_with_limited_results', :page => 4
+                get :index, :params => {:q => 'search_with_limited_results', :page => 4}
                 assert_response :success
                 assert_equal [], assigns(:results)
               end
               def test_search_with_invalid_project_id
-                get :index, :id => 195, :q => 'recipe'
+                get :index, :params => {:id => 195, :q => 'recipe'}
                 assert_response 404
                 assert_nil assigns(:results)
               end
               def test_quick_jump_to_issue
                 # issue of a public project
-                get :index, :q => "3"
+                get :index, :params => {:q => "3"}
                 assert_redirected_to '/issues/3'
                 # issue of a private project
-                get :index, :q => "4"
+                get :index, :params => {:q => "4"}
                 assert_response :success
                 assert_template 'index'
               end
               def test_large_integer
-                get :index, :q => '4615713488'
+                get :index, :params => {:q => '4615713488'}
                 assert_response :success
                 assert_template 'index'
               end
               def test_tokens_with_quotes
-                get :index, :id => 1, :q => '"good bye" hello "bye bye"'
+                get :index, :params => {:id => 1, :q => '"good bye" hello "bye bye"'}
                 assert_equal ["good bye", "hello", "bye bye"], assigns(:tokens)
               end
               def test_results_should_be_escaped_once
                 assert Issue.find(1).update_attributes(:subject => '<subject> escaped_once', :description => '<description> escaped_once')
-                get :index, :q => 'escaped_once'
+                get :index, :params => {:q => 'escaped_once'}
                 assert_response :success
                 assert_select '#search-results' do
                   assert_select 'dt.issue a', :text => /<subject>/
                   assert_select 'dd', :text => /<description>/
                 end
               end
               def test_keywords_should_be_highlighted
                 assert Issue.find(1).update_attributes(:subject => 'subject highlighted', :description => 'description highlighted')
-                get :index, :q => 'highlighted'
+                get :index, :params => {:q => 'highlighted'}
                 assert_response :success
                 assert_select '#search-results' do
                   assert_select 'dt.issue a span.highlight', :text => 'highlighted'
                   assert_select 'dd span.highlight', :text => 'highlighted'
                 end
               end
             end

test/functional/search_custom_fields_visibility_test.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class SearchCustomFieldsVisibilityTest < Redmine::ControllerTest
               tests SearchController
               fixtures :projects,
                        :users,
                        :roles,
                        :members,
                        :member_roles,
                        :issue_statuses,
                        :trackers,
                        :projects_trackers,
                        :enabled_modules,
                        :enumerations,
                        :workflows
               def setup
                 field_attributes = {:field_format => 'string', :is_for_all => true, :is_filter => true, :searchable => true, :trackers => Tracker.all}
                 @fields = []
                 @fields << (@field1 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 1', :visible => true)))
                 @fields << (@field2 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 2', :visible => false, :role_ids => [1, 2])))
                 @fields << (@field3 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 3', :visible => false, :role_ids => [1, 3])))
                 @issue = Issue.generate!(
                   :author_id => 1,
                   :project_id => 1,
                   :tracker_id => 1,
                   :custom_field_values => {@field1.id => 'Value0', @field2.id => 'Value1', @field3.id => 'Value2'}
                 )
                 @user_with_role_on_other_project = User.generate!
                 User.add_to_project(@user_with_role_on_other_project, Project.find(2), Role.find(3))
                 @users_to_test = {
                   User.find(1) => [@field1, @field2, @field3],
                   User.find(3) => [@field1, @field2],
                   @user_with_role_on_other_project => [@field1], # should see field1 only on Project 1
                   User.generate! => [@field1],
                   User.anonymous => [@field1]
                 }
                 Member.where(:project_id => 1).each do |member|
                   member.destroy unless @users_to_test.keys.include?(member.principal)
                 end
               end
               def test_search_should_search_visible_custom_fields_only
                 @users_to_test.each do |user, fields|
                   @request.session[:user_id] = user.id
                   @fields.each_with_index do |field, i|
-                    get :index, :q => "value#{i}"
+                    get :index, :params => {:q => "value#{i}"}
                     assert_response :success
                     # we should get a result only if the custom field is visible
                     if fields.include?(field)
                       assert_equal 1, assigns(:results).size
                     else
                       assert_equal 0, assigns(:results).size
                     end
                   end
                 end
               end
             end

test/functional/sessions_controller_test.rb +9 -9

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class SessionsControllerTest < Redmine::ControllerTest
               include Redmine::I18n
               tests WelcomeController
               fixtures :users, :email_addresses
               def setup
                 Rails.application.config.redmine_verify_sessions = true
               end
               def teardown
                 Rails.application.config.redmine_verify_sessions = false
               end
               def test_session_token_should_be_updated
                 token = Token.create!(:user_id => 2, :action => 'session', :created_on => 10.hours.ago, :updated_on => 10.hours.ago)
                 created = token.reload.created_on
-                get :index, {}, {:user_id => 2, :tk => token.value}
+                get :index, :session => {:user_id => 2, :tk => token.value}
                 assert_response :success
                 token.reload
                 assert_equal created.to_i, token.created_on.to_i
                 assert_not_equal created.to_i, token.updated_on.to_i
                 assert token.updated_on > created
               end
               def test_user_session_should_not_be_reset_if_lifetime_and_timeout_disabled
                 created = 2.years.ago
                 token = Token.create!(:user_id => 2, :action => 'session', :created_on => created, :updated_on => created)
                 with_settings :session_lifetime => '0', :session_timeout => '0' do
-                  get :index, {}, {:user_id => 2, :tk => token.value}
+                  get :index, :session => {:user_id => 2, :tk => token.value}
                   assert_response :success
                 end
               end
               def test_user_session_without_token_should_be_reset
-                get :index, {}, {:user_id => 2}
+                get :index, :session => {:user_id => 2}
                 assert_redirected_to 'http://test.host/login?back_url=http%3A%2F%2Ftest.host%2F'
               end
               def test_expired_user_session_should_be_reset_if_lifetime_enabled
                 created = 2.days.ago
                 token = Token.create!(:user_id => 2, :action => 'session', :created_on => created, :updated_on => created)
                 with_settings :session_timeout => '720' do
-                  get :index, {}, {:user_id => 2, :tk => token.value}
+                  get :index, :session => {:user_id => 2, :tk => token.value}
                   assert_redirected_to 'http://test.host/login?back_url=http%3A%2F%2Ftest.host%2F'
                 end
               end
               def test_valid_user_session_should_not_be_reset_if_lifetime_enabled
                 created = 3.hours.ago
                 token = Token.create!(:user_id => 2, :action => 'session', :created_on => created, :updated_on => created)
                 with_settings :session_timeout => '720' do
-                  get :index, {}, {:user_id => 2, :tk => token.value}
+                  get :index, :session => {:user_id => 2, :tk => token.value}
                   assert_response :success
                 end
               end
               def test_expired_user_session_should_be_reset_if_timeout_enabled
                 created = 4.hours.ago
                 token = Token.create!(:user_id => 2, :action => 'session', :created_on => created, :updated_on => created)
                 with_settings :session_timeout => '60' do
-                  get :index, {}, {:user_id => 2, :tk => token.value}
+                  get :index, :session => {:user_id => 2, :tk => token.value}
                   assert_redirected_to 'http://test.host/login?back_url=http%3A%2F%2Ftest.host%2F'
                 end
               end
               def test_valid_user_session_should_not_be_reset_if_timeout_enabled
                 created = 10.minutes.ago
                 token = Token.create!(:user_id => 2, :action => 'session', :created_on => created, :updated_on => created)
                 with_settings :session_timeout => '60' do
-                  get :index, {}, {:user_id => 2, :tk => token.value}
+                  get :index, :session => {:user_id => 2, :tk => token.value}
                   assert_response :success
                 end
               end
               def test_expired_user_session_should_be_restarted_if_autologin
                 created = 2.hours.ago
                 token = Token.create!(:user_id => 2, :action => 'session', :created_on => created, :updated_on => created)
                 with_settings :session_lifetime => '720', :session_timeout => '60', :autologin => 7 do
                   autologin_token = Token.create!(:user_id => 2, :action => 'autologin', :created_on => 1.day.ago)
                   @request.cookies['autologin'] = autologin_token.value
-                  get :index, {}, {:user_id => 2, :tk => token.value}
+                  get :index, :session => {:user_id => 2, :tk => token.value}
                   assert_equal 2, session[:user_id]
                   assert_response :success
                   assert_not_equal token.value, session[:tk]
                 end
               end
               def test_expired_user_session_should_set_locale
                 set_language_if_valid 'it'
                 user = User.find(2)
                 user.language = 'fr'
                 user.save!
                 created = 4.hours.ago
                 token = Token.create!(:user_id => 2, :action => 'session', :created_on => created, :updated_on => created)
                 with_settings :session_timeout => '60' do
-                  get :index, {}, {:user_id => user.id, :tk => token.value}
+                  get :index, :session => {:user_id => user.id, :tk => token.value}
                   assert_redirected_to 'http://test.host/login?back_url=http%3A%2F%2Ftest.host%2F'
                   assert_include "Veuillez vous reconnecter", flash[:error]
                   assert_equal :fr, current_language
                 end
               end
               def test_anonymous_session_should_not_be_reset
                 with_settings :session_lifetime => '720', :session_timeout => '60' do
                   get :index
                   assert_response :success
                 end
               end
             end

test/functional/settings_controller_test.rb +39 -25

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class SettingsControllerTest < Redmine::ControllerTest
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :users
               def setup
                 User.current = nil
                 @request.session[:user_id] = 1 # admin
               end
               def teardown
                 Setting.delete_all
                 Setting.clear_cache
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'edit'
               end
               def test_get_edit
                 get :edit
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'input[name=?][value=""]', 'settings[enabled_scm][]'
               end
               def test_get_edit_should_preselect_default_issue_list_columns
                 with_settings :issue_list_default_columns => %w(tracker subject status updated_on) do
                   get :edit
                   assert_response :success
                 end
                 assert_select 'select[id=selected_columns][name=?]', 'settings[issue_list_default_columns][]' do
                   assert_select 'option', 4
                   assert_select 'option[value=tracker]', :text => 'Tracker'
                   assert_select 'option[value=subject]', :text => 'Subject'
                   assert_select 'option[value=status]', :text => 'Status'
                   assert_select 'option[value=updated_on]', :text => 'Updated'
                 end
                 assert_select 'select[id=available_columns]' do
                   assert_select 'option[value=tracker]', 0
                   assert_select 'option[value=priority]', :text => 'Priority'
                 end
               end
               def test_get_edit_without_trackers_should_succeed
                 Tracker.delete_all
                 get :edit
                 assert_response :success
               end
               def test_post_edit_notifications
-                post :edit, :settings => {:mail_from => 'functional@test.foo',
+                post :edit, :params => {
-                                          :bcc_recipients  => '0',
+                  :settings => {
-                                          :notified_events => %w(issue_added issue_updated news_added),
+                    :mail_from => 'functional@test.foo',
-                                          :emails_footer => 'Test footer'
+                    :bcc_recipients  => '0',
+                    :notified_events => %w(issue_added issue_updated news_added),
+                    :emails_footer => 'Test footer'
+                  }
+                }
                 assert_redirected_to '/settings'
                 assert_equal 'functional@test.foo', Setting.mail_from
                 assert !Setting.bcc_recipients?
                 assert_equal %w(issue_added issue_updated news_added), Setting.notified_events
                 assert_equal 'Test footer', Setting.emails_footer
               end
               def test_edit_commit_update_keywords
                 with_settings :commit_update_keywords => [
                   {"keywords" => "fixes, resolves", "status_id" => "3"},
                   {"keywords" => "closes", "status_id" => "5", "done_ratio" => "100", "if_tracker_id" => "2"}
                 ] do
                   get :edit
                 end
                 assert_response :success
                 assert_select 'tr.commit-keywords', 2
                 assert_select 'tr.commit-keywords:nth-child(1)' do
                   assert_select 'input[name=?][value=?]', 'settings[commit_update_keywords][keywords][]', 'fixes, resolves'
                   assert_select 'select[name=?]', 'settings[commit_update_keywords][status_id][]' do
                     assert_select 'option[value="3"][selected=selected]'
                   end
                 end
                 assert_select 'tr.commit-keywords:nth-child(2)' do
                   assert_select 'input[name=?][value=?]', 'settings[commit_update_keywords][keywords][]', 'closes'
                   assert_select 'select[name=?]', 'settings[commit_update_keywords][status_id][]' do
                     assert_select 'option[value="5"][selected=selected]', :text => 'Closed'
                   end
                   assert_select 'select[name=?]', 'settings[commit_update_keywords][done_ratio][]' do
                     assert_select 'option[value="100"][selected=selected]', :text => '100 %'
                   end
                   assert_select 'select[name=?]', 'settings[commit_update_keywords][if_tracker_id][]' do
                     assert_select 'option[value="2"][selected=selected]', :text => 'Feature request'
                   end
                 end
               end
               def test_edit_without_commit_update_keywords_should_show_blank_line
                 with_settings :commit_update_keywords => [] do
                   get :edit
                 end
                 assert_response :success
                 assert_select 'tr.commit-keywords', 1 do
                   assert_select 'input[name=?]:not([value])', 'settings[commit_update_keywords][keywords][]'
                 end
               end
               def test_post_edit_commit_update_keywords
-                post :edit, :settings => {
+                post :edit, :params => {
-                  :commit_update_keywords => {
+                  :settings => {
-                    :keywords => ["resolves", "closes"],
+                    :commit_update_keywords => {
-                    :status_id => ["3", "5"],
+                      :keywords => ["resolves", "closes"],
-                    :done_ratio => ["", "100"],
+                      :status_id => ["3", "5"],
-                    :if_tracker_id => ["", "2"]
+                      :done_ratio => ["", "100"],
+                      :if_tracker_id => ["", "2"]
+                    }
                   }
                 }
                 assert_redirected_to '/settings'
                 assert_equal([
                   {"keywords" => "resolves", "status_id" => "3"},
                   {"keywords" => "closes", "status_id" => "5", "done_ratio" => "100", "if_tracker_id" => "2"}
                 ], Setting.commit_update_keywords)
               end
               def test_post_edit_should_send_security_notification_for_notified_settings
                 ActionMailer::Base.deliveries.clear
-                post :edit, :settings => {
+                post :edit, :params => {
-                  :login_required => 1
+                  :settings => {
+                    :login_required => 1
+                  }
                 }
                 assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                 assert_mail_body_match '0.0.0.0', mail
                 assert_mail_body_match I18n.t(:setting_login_required), mail
                 assert_select_email do
                   assert_select 'a[href^=?]', 'http://localhost:3000/settings'
                 end
                 # All admins should receive this
                 recipients = [mail.bcc, mail.cc].flatten
                 User.active.where(admin: true).each do |admin|
                   assert_include admin.mail, recipients
                 end
               end
               def test_post_edit_should_not_send_security_notification_for_non_notified_settings
                 ActionMailer::Base.deliveries.clear
-                post :edit, :settings => {
+                post :edit, :params => {
-                  :app_title => 'MineRed'
+                  :settings => {
+                    :app_title => 'MineRed'
+                  }
                 }
                 assert_nil (mail = ActionMailer::Base.deliveries.last)
               end
               def test_post_edit_should_not_send_security_notification_for_unchanged_settings
                 ActionMailer::Base.deliveries.clear
-                post :edit, :settings => {
+                post :edit, :params => {
-                  :login_required => 0
+                  :settings => {
+                    :login_required => 0
+                  }
                 }
                 assert_nil (mail = ActionMailer::Base.deliveries.last)
               end
               def test_get_plugin_settings
                 ActionController::Base.append_view_path(File.join(Rails.root, "test/fixtures/plugins"))
                 Redmine::Plugin.register :foo do
                   settings :partial => "foo_plugin/foo_plugin_settings"
                 end
                 Setting.plugin_foo = {'sample_setting' => 'Plugin setting value'}
-                get :plugin, :id => 'foo'
+                get :plugin, :params => {:id => 'foo'}
                 assert_response :success
                 assert_template 'plugin'
                 assert_select 'form[action="/settings/plugin/foo"]' do
                   assert_select 'input[name=?][value=?]', 'settings[sample_setting]', 'Plugin setting value'
                 end
               ensure
                 Redmine::Plugin.unregister(:foo)
               end
               def test_get_invalid_plugin_settings
-                get :plugin, :id => 'none'
+                get :plugin, :params => {:id => 'none'}
                 assert_response 404
               end
               def test_get_non_configurable_plugin_settings
                 Redmine::Plugin.register(:foo) {}
-                get :plugin, :id => 'foo'
+                get :plugin, :params => {:id => 'foo'}
                 assert_response 404
               ensure
                 Redmine::Plugin.unregister(:foo)
               end
               def test_post_plugin_settings
                 Redmine::Plugin.register(:foo) do
                   settings :partial => 'not blank', # so that configurable? is true
                     :default => {'sample_setting' => 'Plugin setting value'}
                 end
-                post :plugin, :id => 'foo', :settings => {'sample_setting' => 'Value'}
+                post :plugin, :params => {
+                  :id => 'foo',
+                  :settings => {'sample_setting' => 'Value'}
+                }
                 assert_redirected_to '/settings/plugin/foo'
                 assert_equal({'sample_setting' => 'Value'}, Setting.plugin_foo)
               end
               def test_post_non_configurable_plugin_settings
                 Redmine::Plugin.register(:foo) {}
-                post :plugin, :id => 'foo', :settings => {'sample_setting' => 'Value'}
+                post :plugin, :params => {
+                  :id => 'foo',
+                  :settings => {'sample_setting' => 'Value'}
+                }
                 assert_response 404
               ensure
                 Redmine::Plugin.unregister(:foo)
               end
             end

test/functional/sys_controller_test.rb +16 -12

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class SysControllerTest < Redmine::ControllerTest
               fixtures :projects, :repositories, :enabled_modules
               def setup
                 Setting.sys_api_enabled = '1'
                 Setting.enabled_scm = %w(Subversion Git)
               end
               def teardown
                 Setting.clear_cache
               end
               def test_projects_with_repository_enabled
                 get :projects
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                 assert_select 'projects' do
                   assert_select 'project', Project.active.has_module(:repository).count
                   assert_select 'project' do
                     assert_select 'identifier'
                     assert_select 'is-public'
                   end
                 end
                 assert_select 'extra-info', 0
                 assert_select 'extra_info', 0
               end
               def test_create_project_repository
                 assert_nil Project.find(4).repository
-                post :create_project_repository, :id => 4,
+                post :create_project_repository, :params => {
-                                                 :vendor => 'Subversion',
+                  :id => 4,
-                                                 :repository => { :url => 'file:///create/project/repository/subproject2'}
+                  :vendor => 'Subversion',
+                  :repository => { :url => 'file:///create/project/repository/subproject2'}
+                }
                 assert_response :created
                 assert_equal 'application/xml', @response.content_type
                 r = Project.find(4).repository
                 assert r.is_a?(Repository::Subversion)
                 assert_equal 'file:///create/project/repository/subproject2', r.url
                 assert_select 'repository-subversion' do
                   assert_select 'id', :text => r.id.to_s
                   assert_select 'url', :text => r.url
                 end
                 assert_select 'extra-info', 0
                 assert_select 'extra_info', 0
               end
               def test_create_already_existing
-                post :create_project_repository, :id => 1,
+                post :create_project_repository, :params => {
+                  :id => 1,
                   :vendor => 'Subversion',
                   :repository => { :url => 'file:///create/project/repository/subproject2'}
+                }
                 assert_response :conflict
               end
               def test_create_with_failure
-                post :create_project_repository, :id => 4,
+                post :create_project_repository, :params => {
+                  :id => 4,
                   :vendor => 'Subversion',
                   :repository => { :url => 'invalid url'}
+                }
                 assert_response :unprocessable_entity
               end
               def test_fetch_changesets
                 Repository::Subversion.any_instance.expects(:fetch_changesets).twice.returns(true)
                 get :fetch_changesets
                 assert_response :success
               end
               def test_fetch_changesets_one_project_by_identifier
                 Repository::Subversion.any_instance.expects(:fetch_changesets).once.returns(true)
-                get :fetch_changesets, :id => 'ecookbook'
+                get :fetch_changesets, :params => {:id => 'ecookbook'}
                 assert_response :success
               end
               def test_fetch_changesets_one_project_by_id
                 Repository::Subversion.any_instance.expects(:fetch_changesets).once.returns(true)
-                get :fetch_changesets, :id => '1'
+                get :fetch_changesets, :params => {:id => '1'}
                 assert_response :success
               end
               def test_fetch_changesets_unknown_project
-                get :fetch_changesets, :id => 'unknown'
+                get :fetch_changesets, :params => {:id => 'unknown'}
                 assert_response 404
               end
               def test_disabled_ws_should_respond_with_403_error
                 with_settings :sys_api_enabled => '0' do
                   get :projects
                   assert_response 403
                 end
               end
               def test_api_key
                 with_settings :sys_api_key => 'my_secret_key' do
-                  get :projects, :key => 'my_secret_key'
+                  get :projects, :params => {:key => 'my_secret_key'}
                   assert_response :success
                 end
               end
               def test_wrong_key_should_respond_with_403_error
                 with_settings :sys_api_enabled => 'my_secret_key' do
-                  get :projects, :key => 'wrong_key'
+                  get :projects, :params => {:key => 'wrong_key'}
                   assert_response 403
                 end
               end
             end

test/functional/time_entry_reports_controller_test.rb +52 -27

             # -*- coding: utf-8 -*-
             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class TimeEntryReportsControllerTest < Redmine::ControllerTest
               tests TimelogController
               fixtures :projects, :enabled_modules, :roles, :members, :member_roles,
                        :email_addresses,
                        :issues, :time_entries, :users, :trackers, :enumerations,
                        :issue_statuses, :custom_fields, :custom_values,
                        :projects_trackers, :custom_fields_trackers,
                        :custom_fields_projects
               include Redmine::I18n
               def setup
                 Setting.default_language = "en"
               end
               def test_report_at_project_level
-                get :report, :project_id => 'ecookbook'
+                get :report, :params => {:project_id => 'ecookbook'}
                 assert_response :success
                 assert_template 'report'
                 assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries/report'
               end
               def test_report_all_projects
                 get :report
                 assert_response :success
                 assert_template 'report'
                 assert_select 'form#query_form[action=?]', '/time_entries/report'
               end
               def test_report_all_projects_denied
                 r = Role.anonymous
                 r.permissions.delete(:view_time_entries)
                 r.permissions_will_change!
                 r.save
                 get :report
                 assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Ftime_entries%2Freport'
               end
               def test_report_all_projects_one_criteria
-                get :report, :columns => 'week', :from => "2007-04-01", :to => "2007-04-30", :criteria => ['project']
+                get :report, :params => {:columns => 'week', :from => "2007-04-01", :to => "2007-04-30", :criteria => ['project']}
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:report)
                 assert_equal "8.65", "%.2f" % assigns(:report).total_hours
               end
               def test_report_all_time
-                get :report, :project_id => 1, :criteria => ['project', 'issue']
+                get :report, :params => {:project_id => 1, :criteria => ['project', 'issue']}
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:report)
                 assert_equal "162.90", "%.2f" % assigns(:report).total_hours
               end
               def test_report_all_time_by_day
-                get :report, :project_id => 1, :criteria => ['project', 'issue'], :columns => 'day'
+                get :report, :params => {:project_id => 1, :criteria => ['project', 'issue'], :columns => 'day'}
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:report)
                 assert_equal "162.90", "%.2f" % assigns(:report).total_hours
                 assert_select 'th', :text => '2007-03-12'
               end
               def test_report_one_criteria
-                get :report, :project_id => 1, :columns => 'week', :from => "2007-04-01", :to => "2007-04-30", :criteria => ['project']
+                get :report, :params => {:project_id => 1, :columns => 'week', :from => "2007-04-01", :to => "2007-04-30", :criteria => ['project']}
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:report)
                 assert_equal "8.65", "%.2f" % assigns(:report).total_hours
               end
               def test_report_two_criteria
-                get :report, :project_id => 1, :columns => 'month', :from => "2007-01-01", :to => "2007-12-31", :criteria => ["user", "activity"]
+                get :report, :params => {:project_id => 1, :columns => 'month', :from => "2007-01-01", :to => "2007-12-31", :criteria => ["user", "activity"]}
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:report)
                 assert_equal "162.90", "%.2f" % assigns(:report).total_hours
               end
               def test_report_custom_field_criteria_with_multiple_values_on_single_value_custom_field_should_not_fail
                 field = TimeEntryCustomField.create!(:name => 'multi', :field_format => 'list', :possible_values => ['value1', 'value2'])
                 entry = TimeEntry.create!(:project => Project.find(1), :hours => 1, :activity_id => 10, :user => User.find(2), :spent_on => Date.today)
                 CustomValue.create!(:customized => entry, :custom_field => field, :value => 'value1')
                 CustomValue.create!(:customized => entry, :custom_field => field, :value => 'value2')
-                get :report, :project_id => 1, :columns => 'day', :criteria => ["cf_#{field.id}"]
+                get :report, :params => {:project_id => 1, :columns => 'day', :criteria => ["cf_#{field.id}"]}
                 assert_response :success
               end
               def test_report_multiple_values_custom_fields_should_not_be_proposed
                 TimeEntryCustomField.create!(:name => 'Single', :field_format => 'list', :possible_values => ['value1', 'value2'])
                 TimeEntryCustomField.create!(:name => 'Multi', :field_format => 'list', :multiple => true, :possible_values => ['value1', 'value2'])
-                get :report, :project_id => 1
+                get :report, :params => {:project_id => 1}
                 assert_response :success
                 assert_select 'select[name=?]', 'criteria[]' do
                   assert_select 'option', :text => 'Single'
                   assert_select 'option', :text => 'Multi', :count => 0
                 end
               end
               def test_report_one_day
-                get :report, :project_id => 1, :columns => 'day', :from => "2007-03-23", :to => "2007-03-23", :criteria => ["user", "activity"]
+                get :report, :params => {:project_id => 1, :columns => 'day', :from => "2007-03-23", :to => "2007-03-23", :criteria => ["user", "activity"]}
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:report)
                 assert_equal "4.25", "%.2f" % assigns(:report).total_hours
               end
               def test_report_by_week_should_use_commercial_year
                 TimeEntry.delete_all
                 TimeEntry.generate!(:hours => '2', :spent_on => '2009-12-25') # 2009-52
                 TimeEntry.generate!(:hours => '4', :spent_on => '2009-12-31') # 2009-53
                 TimeEntry.generate!(:hours => '8', :spent_on => '2010-01-01') # 2009-53
                 TimeEntry.generate!(:hours => '16', :spent_on => '2010-01-05') # 2010-1
-                get :report, :columns => 'week', :from => "2009-12-25", :to => "2010-01-05", :criteria => ["project"]
+                get :report, :params => {:columns => 'week', :from => "2009-12-25", :to => "2010-01-05", :criteria => ["project"]}
                 assert_response :success
                 assert_select '#time-report thead tr' do
                   assert_select 'th:nth-child(1)', :text => 'Project'
                   assert_select 'th:nth-child(2)', :text => '2009-52'
                   assert_select 'th:nth-child(3)', :text => '2009-53'
                   assert_select 'th:nth-child(4)', :text => '2010-1'
                   assert_select 'th:nth-child(5)', :text => 'Total time'
                 end
                 assert_select '#time-report tbody tr' do
                   assert_select 'td:nth-child(1)', :text => 'eCookbook'
                   assert_select 'td:nth-child(2)', :text => '2.00'
                   assert_select 'td:nth-child(3)', :text => '12.00'
                   assert_select 'td:nth-child(4)', :text => '16.00'
                   assert_select 'td:nth-child(5)', :text => '30.00' # Total
                 end
               end
               def test_report_should_propose_association_custom_fields
                 get :report
                 assert_response :success
                 assert_template 'report'
                 assert_select 'select[name=?]', 'criteria[]' do
                   assert_select 'option[value=cf_1]', {:text => 'Database'}, 'Issue custom field not found'
                   assert_select 'option[value=cf_3]', {:text => 'Development status'}, 'Project custom field not found'
                   assert_select 'option[value=cf_7]', {:text => 'Billable'}, 'TimeEntryActivity custom field not found'
                 end
               end
               def test_report_with_association_custom_fields
-                get :report, :criteria => ['cf_1', 'cf_3', 'cf_7']
+                get :report, :params => {:criteria => ['cf_1', 'cf_3', 'cf_7']}
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:report)
                 assert_equal 3, assigns(:report).criteria.size
                 assert_equal "162.90", "%.2f" % assigns(:report).total_hours
                 # Custom fields columns
                 assert_select 'th', :text => 'Database'
                 assert_select 'th', :text => 'Development status'
                 assert_select 'th', :text => 'Billable'
                 # Custom field row
                 assert_select 'tr' do
                   assert_select 'td', :text => 'MySQL'
                   assert_select 'td.hours', :text => '1.00'
                 end
               end
               def test_report_one_criteria_no_result
-                get :report, :project_id => 1, :columns => 'week', :from => "1998-04-01", :to => "1998-04-30", :criteria => ['project']
+                get :report, :params => {:project_id => 1, :columns => 'week', :from => "1998-04-01", :to => "1998-04-30", :criteria => ['project']}
                 assert_response :success
                 assert_template 'report'
                 assert_not_nil assigns(:report)
                 assert_equal "0.00", "%.2f" % assigns(:report).total_hours
               end
               def test_report_status_criterion
-                get :report, :project_id => 1, :criteria => ['status']
+                get :report, :params => {:project_id => 1, :criteria => ['status']}
                 assert_response :success
                 assert_template 'report'
                 assert_select 'th', :text => 'Status'
                 assert_select 'td', :text => 'New'
               end
               def test_report_all_projects_csv_export
-                get :report, :columns => 'month', :from => "2007-01-01", :to => "2007-06-30",
+                get :report, :params => {
-                    :criteria => ["project", "user", "activity"], :format => "csv"
+                  :columns => 'month',
+                  :from => "2007-01-01",
+                  :to => "2007-06-30",
+                  :criteria => ["project", "user", "activity"],
+                  :format => "csv"
+                }
                 assert_response :success
                 assert_equal 'text/csv; header=present', @response.content_type
                 lines = @response.body.chomp.split("\n")
                 # Headers
                 assert_equal 'Project,User,Activity,2007-3,2007-4,Total time', lines.first
                 # Total row
                 assert_equal 'Total time,"","",154.25,8.65,162.90', lines.last
               end
               def test_report_csv_export
-                get :report, :project_id => 1, :columns => 'month',
+                get :report, :params => {
-                    :from => "2007-01-01", :to => "2007-06-30",
+                  :project_id => 1,
-                    :criteria => ["project", "user", "activity"], :format => "csv"
+                  :columns => 'month',
+                  :from => "2007-01-01",
+                  :to => "2007-06-30",
+                  :criteria => ["project", "user", "activity"],
+                  :format => "csv"
+                }
                 assert_response :success
                 assert_equal 'text/csv; header=present', @response.content_type
                 lines = @response.body.chomp.split("\n")
                 # Headers
                 assert_equal 'Project,User,Activity,2007-3,2007-4,Total time', lines.first
                 # Total row
                 assert_equal 'Total time,"","",154.25,8.65,162.90', lines.last
               end
               def test_csv_big_5
                 str_utf8  = "\xe4\xb8\x80\xe6\x9c\x88".force_encoding('UTF-8')
                 str_big5  = "\xa4@\xa4\xeb".force_encoding('Big5')
                 user = User.find_by_id(3)
                 user.firstname = str_utf8
                 user.lastname  = "test-lastname"
                 assert user.save
                 comments = "test_csv_big_5"
                 te1 = TimeEntry.create(:spent_on => '2011-11-11',
                                        :hours    => 7.3,
                                        :project  => Project.find(1),
                                        :user     => user,
                                        :activity => TimeEntryActivity.find_by_name('Design'),
                                        :comments => comments)
                 te2 = TimeEntry.find_by_comments(comments)
                 assert_not_nil te2
                 assert_equal 7.3, te2.hours
                 assert_equal 3, te2.user_id
                 with_settings :default_language => "zh-TW" do
-                  get :report, :project_id => 1, :columns => 'day',
+                  get :report, :params => {
-                      :from => "2011-11-11", :to => "2011-11-11",
+                    :project_id => 1,
-                      :criteria => ["user"], :format => "csv"
+                    :columns => 'day',
+                    :from => "2011-11-11",
+                    :to => "2011-11-11",
+                    :criteria => ["user"],
+                    :format => "csv"
+                  }
                 end
                 assert_response :success
                 assert_equal 'text/csv; header=present', @response.content_type
                 lines = @response.body.chomp.split("\n")
                 # Headers
                 s1 = "\xa5\xce\xa4\xe1,2011-11-11,\xa4u\xae\xc9\xc1`\xadp".force_encoding('Big5')
                 s2 = "\xa4u\xae\xc9\xc1`\xadp".force_encoding('Big5')
                 assert_equal s1, lines.first
                 # Total row
                 assert_equal "#{str_big5} #{user.lastname},7.30,7.30", lines[1]
                 assert_equal "#{s2},7.30,7.30", lines[2]
                 str_tw = "Traditional Chinese (\xe7\xb9\x81\xe9\xab\x94\xe4\xb8\xad\xe6\x96\x87)".force_encoding('UTF-8')
                 assert_equal str_tw, l(:general_lang_name)
                 assert_equal 'Big5', l(:general_csv_encoding)
                 assert_equal ',', l(:general_csv_separator)
                 assert_equal '.', l(:general_csv_decimal_separator)
               end
               def test_csv_cannot_convert_should_be_replaced_big_5
                 str_utf8  = "\xe4\xbb\xa5\xe5\x86\x85".force_encoding('UTF-8')
                 user = User.find_by_id(3)
                 user.firstname = str_utf8
                 user.lastname  = "test-lastname"
                 assert user.save
                 comments = "test_replaced"
                 te1 = TimeEntry.create(:spent_on => '2011-11-11',
                                        :hours    => 7.3,
                                        :project  => Project.find(1),
                                        :user     => user,
                                        :activity => TimeEntryActivity.find_by_name('Design'),
                                        :comments => comments)
                 te2 = TimeEntry.find_by_comments(comments)
                 assert_not_nil te2
                 assert_equal 7.3, te2.hours
                 assert_equal 3, te2.user_id
                 with_settings :default_language => "zh-TW" do
-                  get :report, :project_id => 1, :columns => 'day',
+                  get :report, :params => {
-                      :from => "2011-11-11", :to => "2011-11-11",
+                    :project_id => 1,
-                      :criteria => ["user"], :format => "csv"
+                    :columns => 'day',
+                    :from => "2011-11-11",
+                    :to => "2011-11-11",
+                    :criteria => ["user"],
+                    :format => "csv"
+                  }
                 end
                 assert_response :success
                 assert_equal 'text/csv; header=present', @response.content_type
                 lines = @response.body.chomp.split("\n")
                 # Headers
                 s1 = "\xa5\xce\xa4\xe1,2011-11-11,\xa4u\xae\xc9\xc1`\xadp".force_encoding('Big5')
                 assert_equal s1, lines.first
                 # Total row
                 s2 = "\xa5H?".force_encoding('Big5')
                 assert_equal "#{s2} #{user.lastname},7.30,7.30", lines[1]
               end
               def test_csv_fr
                 with_settings :default_language => "fr" do
                   str1  = "test_csv_fr"
                   user = User.find_by_id(3)
                   te1 = TimeEntry.create(:spent_on => '2011-11-11',
                                          :hours    => 7.3,
                                          :project  => Project.find(1),
                                          :user     => user,
                                          :activity => TimeEntryActivity.find_by_name('Design'),
                                          :comments => str1)
                   te2 = TimeEntry.find_by_comments(str1)
                   assert_not_nil te2
                   assert_equal 7.3, te2.hours
                   assert_equal 3, te2.user_id
-                  get :report, :project_id => 1, :columns => 'day',
+                  get :report, :params => {
-                      :from => "2011-11-11", :to => "2011-11-11",
+                    :project_id => 1,
-                      :criteria => ["user"], :format => "csv"
+                    :columns => 'day',
+                    :from => "2011-11-11",
+                    :to => "2011-11-11",
+                    :criteria => ["user"],
+                    :format => "csv"
+                  }
                   assert_response :success
                   assert_equal 'text/csv; header=present', @response.content_type
                   lines = @response.body.chomp.split("\n")
                   # Headers
                   s1 = "Utilisateur;2011-11-11;Temps total".force_encoding('ISO-8859-1')
                   s2 = "Temps total".force_encoding('ISO-8859-1')
                   assert_equal s1, lines.first
                   # Total row
                   assert_equal "#{user.firstname} #{user.lastname};7,30;7,30", lines[1]
                   assert_equal "#{s2};7,30;7,30", lines[2]
                   str_fr = "French (Fran\xc3\xa7ais)".force_encoding('UTF-8')
                   assert_equal str_fr, l(:general_lang_name)
                   assert_equal 'ISO-8859-1', l(:general_csv_encoding)
                   assert_equal ';', l(:general_csv_separator)
                   assert_equal ',', l(:general_csv_decimal_separator)
                 end
               end
             end

test/functional/timelog_controller_test.rb +235 -137

             # -*- coding: utf-8 -*-
             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class TimelogControllerTest < Redmine::ControllerTest
               fixtures :projects, :enabled_modules, :roles, :members,
                        :member_roles, :issues, :time_entries, :users,
                        :trackers, :enumerations, :issue_statuses,
                        :custom_fields, :custom_values,
                        :projects_trackers, :custom_fields_trackers,
                        :custom_fields_projects
               include Redmine::I18n
               def test_new
                 @request.session[:user_id] = 3
                 get :new
                 assert_response :success
                 assert_template 'new'
                 assert_select 'input[name=?][type=hidden]', 'project_id', 0
                 assert_select 'input[name=?][type=hidden]', 'issue_id', 0
                 assert_select 'select[name=?]', 'time_entry[project_id]' do
                   # blank option for project
                   assert_select 'option[value=""]'
                 end
               end
               def test_new_with_project_id
                 @request.session[:user_id] = 3
-                get :new, :project_id => 1
+                get :new, :params => {:project_id => 1}
                 assert_response :success
                 assert_template 'new'
                 assert_select 'input[name=?][type=hidden]', 'project_id'
                 assert_select 'input[name=?][type=hidden]', 'issue_id', 0
                 assert_select 'select[name=?]', 'time_entry[project_id]', 0
               end
               def test_new_with_issue_id
                 @request.session[:user_id] = 3
-                get :new, :issue_id => 2
+                get :new, :params => {:issue_id => 2}
                 assert_response :success
                 assert_template 'new'
                 assert_select 'input[name=?][type=hidden]', 'project_id', 0
                 assert_select 'input[name=?][type=hidden]', 'issue_id'
                 assert_select 'select[name=?]', 'time_entry[project_id]', 0
               end
               def test_new_without_project_should_prefill_the_form
                 @request.session[:user_id] = 3
-                get :new, :time_entry => {:project_id => '1'}
+                get :new, :params => {:time_entry => {:project_id => '1'}}
                 assert_response :success
                 assert_template 'new'
                 assert_select 'select[name=?]', 'time_entry[project_id]' do
                   assert_select 'option[value="1"][selected=selected]'
                 end
               end
               def test_new_without_project_should_deny_without_permission
                 Role.all.each {|role| role.remove_permission! :log_time}
                 @request.session[:user_id] = 3
                 get :new
                 assert_response 403
               end
               def test_new_should_select_default_activity
                 @request.session[:user_id] = 3
-                get :new, :project_id => 1
+                get :new, :params => {:project_id => 1}
                 assert_response :success
                 assert_select 'select[name=?]', 'time_entry[activity_id]' do
                   assert_select 'option[selected=selected]', :text => 'Development'
                 end
               end
               def test_new_should_only_show_active_time_entry_activities
                 @request.session[:user_id] = 3
-                get :new, :project_id => 1
+                get :new, :params => {:project_id => 1}
                 assert_response :success
                 assert_select 'option', :text => 'Inactive Activity', :count => 0
               end
               def test_post_new_as_js_should_update_activity_options
                 @request.session[:user_id] = 3
-                post :new, :time_entry => {:project_id => 1}, :format => 'js'
+                post :new, :params => {:time_entry => {:project_id => 1}, :format => 'js'}
                 assert_response :success
                 assert_include '#time_entry_activity_id', response.body
               end
               def test_get_edit_existing_time
                 @request.session[:user_id] = 2
-                get :edit, :id => 2, :project_id => nil
+                get :edit, :params => {:id => 2, :project_id => nil}
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'form[action=?]', '/time_entries/2'
               end
               def test_get_edit_with_an_existing_time_entry_with_inactive_activity
                 te = TimeEntry.find(1)
                 te.activity = TimeEntryActivity.find_by_name("Inactive Activity")
                 te.save!(:validate => false)
                 @request.session[:user_id] = 1
-                get :edit, :project_id => 1, :id => 1
+                get :edit, :params => {:project_id => 1, :id => 1}
                 assert_response :success
                 assert_template 'edit'
                 # Blank option since nothing is pre-selected
                 assert_select 'option', :text => '--- Please select ---'
               end
               def test_post_create
                 @request.session[:user_id] = 3
                 assert_difference 'TimeEntry.count' do
-                  post :create, :project_id => 1,
+                  post :create, :params => {
-                            :time_entry => {:comments => 'Some work on TimelogControllerTest',
+                    :project_id => 1,
-                                            # Not the default activity
+                    :time_entry => {:comments => 'Some work on TimelogControllerTest',
-                                            :activity_id => '11',
+                      # Not the default activity
-                                            :spent_on => '2008-03-14',
+                      :activity_id => '11',
-                                            :issue_id => '1',
+                      :spent_on => '2008-03-14',
-                                            :hours => '7.3'}
+                      :issue_id => '1',
+                      :hours => '7.3'
+                    }
+                  }
                   assert_redirected_to '/projects/ecookbook/time_entries'
                 end
                 t = TimeEntry.order('id DESC').first
                 assert_not_nil t
                 assert_equal 'Some work on TimelogControllerTest', t.comments
                 assert_equal 1, t.project_id
                 assert_equal 1, t.issue_id
                 assert_equal 11, t.activity_id
                 assert_equal 7.3, t.hours
                 assert_equal 3, t.user_id
               end
               def test_post_create_with_blank_issue
                 @request.session[:user_id] = 3
                 assert_difference 'TimeEntry.count' do
-                  post :create, :project_id => 1,
+                  post :create, :params => {
-                            :time_entry => {:comments => 'Some work on TimelogControllerTest',
+                    :project_id => 1,
-                                            # Not the default activity
+                    :time_entry => {
-                                            :activity_id => '11',
+                      :comments => 'Some work on TimelogControllerTest',
-                                            :issue_id => '',
+                      # Not the default activity
-                                            :spent_on => '2008-03-14',
+                      :activity_id => '11',
-                                            :hours => '7.3'}
+                      :issue_id => '',
+                      :spent_on => '2008-03-14',
+                      :hours => '7.3'
+                    }
+                  }
                   assert_redirected_to '/projects/ecookbook/time_entries'
                 end
                 t = TimeEntry.order('id DESC').first
                 assert_not_nil t
                 assert_equal 'Some work on TimelogControllerTest', t.comments
                 assert_equal 1, t.project_id
                 assert_nil t.issue_id
                 assert_equal 11, t.activity_id
                 assert_equal 7.3, t.hours
                 assert_equal 3, t.user_id
               end
               def test_create_on_project_with_time_tracking_disabled_should_fail
                 Project.find(1).disable_module! :time_tracking
                 @request.session[:user_id] = 2
                 assert_no_difference 'TimeEntry.count' do
-                  post :create, :time_entry => {
+                  post :create, :params => {
-                    :project_id => '1', :issue_id => '',
+                    :time_entry => {
-                    :activity_id => '11', :spent_on => '2008-03-14', :hours => '7.3'
+                      :project_id => '1', :issue_id => '',
+                      :activity_id => '11', :spent_on => '2008-03-14', :hours => '7.3'
+                    }
                   }
                 end
               end
               def test_create_on_project_without_permission_should_fail
                 Role.find(1).remove_permission! :log_time
                 @request.session[:user_id] = 2
                 assert_no_difference 'TimeEntry.count' do
-                  post :create, :time_entry => {
+                  post :create, :params => {
-                    :project_id => '1', :issue_id => '',
+                    :time_entry => {
-                    :activity_id => '11', :spent_on => '2008-03-14', :hours => '7.3'
+                      :project_id => '1', :issue_id => '',
+                      :activity_id => '11', :spent_on => '2008-03-14', :hours => '7.3'
+                    }
                   }
                 end
               end
               def test_create_on_issue_in_project_with_time_tracking_disabled_should_fail
                 Project.find(1).disable_module! :time_tracking
                 @request.session[:user_id] = 2
                 assert_no_difference 'TimeEntry.count' do
-                  post :create, :time_entry => {
+                  post :create, :params => {
-                    :project_id => '', :issue_id => '1',
+                    :time_entry => {
-                    :activity_id => '11', :spent_on => '2008-03-14', :hours => '7.3'
+                      :project_id => '', :issue_id => '1',
+                      :activity_id => '11', :spent_on => '2008-03-14', :hours => '7.3'
+                    }
                   }
                   assert_select_error /Issue is invalid/
                 end
               end
               def test_create_on_issue_in_project_without_permission_should_fail
                 Role.find(1).remove_permission! :log_time
                 @request.session[:user_id] = 2
                 assert_no_difference 'TimeEntry.count' do
-                  post :create, :time_entry => {
+                  post :create, :params => {
-                    :project_id => '', :issue_id => '1',
+                    :time_entry => {
-                    :activity_id => '11', :spent_on => '2008-03-14', :hours => '7.3'
+                      :project_id => '', :issue_id => '1',
+                      :activity_id => '11', :spent_on => '2008-03-14', :hours => '7.3'
+                    }
                   }
                   assert_select_error /Issue is invalid/
                 end
               end
               def test_create_on_issue_that_is_not_visible_should_not_disclose_subject
                 issue = Issue.generate!(:subject => "issue_that_is_not_visible", :is_private => true)
                 assert !issue.visible?(User.find(3))
                 @request.session[:user_id] = 3
                 assert_no_difference 'TimeEntry.count' do
-                  post :create, :time_entry => {
+                  post :create, :params => {
-                    :project_id => '', :issue_id => issue.id.to_s,
+                    :time_entry => {
-                    :activity_id => '11', :spent_on => '2008-03-14', :hours => '7.3'
+                      :project_id => '', :issue_id => issue.id.to_s,
+                      :activity_id => '11', :spent_on => '2008-03-14', :hours => '7.3'
+                    }
                   }
                 end
                 assert_select_error /Issue is invalid/
                 assert_select "input[name=?][value=?]", "time_entry[issue_id]", issue.id.to_s
                 assert_select "#time_entry_issue", 0
                 assert !response.body.include?('issue_that_is_not_visible')
               end
               def test_create_and_continue_at_project_level
                 @request.session[:user_id] = 2
                 assert_difference 'TimeEntry.count' do
-                  post :create, :time_entry => {:project_id => '1',
+                  post :create, :params => {
-                                                :activity_id => '11',
+                    :time_entry => {
-                                                :issue_id => '',
+                      :project_id => '1',
-                                                :spent_on => '2008-03-14',
+                      :activity_id => '11',
-                                                :hours => '7.3'},
+                      :issue_id => '',
-                                :continue => '1'
+                      :spent_on => '2008-03-14',
+                      :hours => '7.3'
+                    },
+                    :continue => '1'
+                  }
                   assert_redirected_to '/time_entries/new?time_entry%5Bactivity_id%5D=11&time_entry%5Bissue_id%5D=&time_entry%5Bproject_id%5D=1'
                 end
               end
               def test_create_and_continue_at_issue_level
                 @request.session[:user_id] = 2
                 assert_difference 'TimeEntry.count' do
-                  post :create, :time_entry => {:project_id => '',
+                  post :create, :params => {
-                                                :activity_id => '11',
+                    :time_entry => {
-                                                :issue_id => '1',
+                      :project_id => '',
-                                                :spent_on => '2008-03-14',
+                      :activity_id => '11',
-                                                :hours => '7.3'},
+                      :issue_id => '1',
-                                :continue => '1'
+                      :spent_on => '2008-03-14',
+                      :hours => '7.3'
+                    },
+                    :continue => '1'
+                  }
                   assert_redirected_to '/time_entries/new?time_entry%5Bactivity_id%5D=11&time_entry%5Bissue_id%5D=1&time_entry%5Bproject_id%5D='
                 end
               end
               def test_create_and_continue_with_project_id
                 @request.session[:user_id] = 2
                 assert_difference 'TimeEntry.count' do
-                  post :create, :project_id => 1,
+                  post :create, :params => {
-                                :time_entry => {:activity_id => '11',
+                    :project_id => 1,
-                                                :issue_id => '',
+                    :time_entry => {
-                                                :spent_on => '2008-03-14',
+                      :activity_id => '11',
-                                                :hours => '7.3'},
+                      :issue_id => '',
-                                :continue => '1'
+                      :spent_on => '2008-03-14',
+                      :hours => '7.3'
+                    },
+                    :continue => '1'
+                  }
                   assert_redirected_to '/projects/ecookbook/time_entries/new?time_entry%5Bactivity_id%5D=11&time_entry%5Bissue_id%5D=&time_entry%5Bproject_id%5D='
                 end
               end
               def test_create_and_continue_with_issue_id
                 @request.session[:user_id] = 2
                 assert_difference 'TimeEntry.count' do
-                  post :create, :issue_id => 1,
+                  post :create, :params => {
-                                :time_entry => {:activity_id => '11',
+                    :issue_id => 1,
-                                                :issue_id => '1',
+                    :time_entry => {
-                                                :spent_on => '2008-03-14',
+                      :activity_id => '11',
-                                                :hours => '7.3'},
+                      :issue_id => '1',
-                                :continue => '1'
+                      :spent_on => '2008-03-14',
+                      :hours => '7.3'
+                    },
+                    :continue => '1'
+                  }
                   assert_redirected_to '/issues/1/time_entries/new?time_entry%5Bactivity_id%5D=11&time_entry%5Bissue_id%5D=1&time_entry%5Bproject_id%5D='
                 end
               end
               def test_create_without_log_time_permission_should_be_denied
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :log_time
-                post :create, :project_id => 1,
+                post :create, :params => {
-                            :time_entry => {:activity_id => '11',
+                  :project_id => 1,
-                                            :issue_id => '',
+                  :time_entry => {
-                                            :spent_on => '2008-03-14',
+                    :activity_id => '11',
-                                            :hours => '7.3'}
+                    :issue_id => '',
+                    :spent_on => '2008-03-14',
+                    :hours => '7.3'
+                  }
+                }
                 assert_response 403
               end
               def test_create_without_project_and_issue_should_fail
                 @request.session[:user_id] = 2
-                post :create, :time_entry => {:issue_id => ''}
+                post :create, :params => {:time_entry => {:issue_id => ''}}
                 assert_response :success
                 assert_template 'new'
               end
               def test_create_with_failure
                 @request.session[:user_id] = 2
-                post :create, :project_id => 1,
+                post :create, :params => {
-                            :time_entry => {:activity_id => '',
+                  :project_id => 1,
-                                            :issue_id => '',
+                  :time_entry => {
-                                            :spent_on => '2008-03-14',
+                    :activity_id => '',
-                                            :hours => '7.3'}
+                    :issue_id => '',
+                    :spent_on => '2008-03-14',
+                    :hours => '7.3'
+                  }
+                }
                 assert_response :success
                 assert_template 'new'
               end
               def test_create_without_project
                 @request.session[:user_id] = 2
                 assert_difference 'TimeEntry.count' do
-                  post :create, :time_entry => {:project_id => '1',
+                  post :create, :params => {
-                                              :activity_id => '11',
+                    :time_entry => {
-                                              :issue_id => '',
+                      :project_id => '1',
-                                              :spent_on => '2008-03-14',
+                      :activity_id => '11',
-                                              :hours => '7.3'}
+                      :issue_id => '',
+                      :spent_on => '2008-03-14',
+                      :hours => '7.3'
+                    }
+                  }
                 end
                 assert_redirected_to '/projects/ecookbook/time_entries'
                 time_entry = TimeEntry.order('id DESC').first
                 assert_equal 1, time_entry.project_id
               end
               def test_create_without_project_should_fail_with_issue_not_inside_project
                 @request.session[:user_id] = 2
                 assert_no_difference 'TimeEntry.count' do
-                  post :create, :time_entry => {:project_id => '1',
+                  post :create, :params => {
-                                              :activity_id => '11',
+                    :time_entry => {
-                                              :issue_id => '5',
+                      :project_id => '1',
-                                              :spent_on => '2008-03-14',
+                      :activity_id => '11',
-                                              :hours => '7.3'}
+                      :issue_id => '5',
+                      :spent_on => '2008-03-14',
+                      :hours => '7.3'
+                    }
+                  }
                 end
                 assert_response :success
                 assert assigns(:time_entry).errors[:issue_id].present?
               end
               def test_create_without_project_should_deny_without_permission
                 @request.session[:user_id] = 2
                 Project.find(3).disable_module!(:time_tracking)
                 assert_no_difference 'TimeEntry.count' do
-                  post :create, :time_entry => {:project_id => '3',
+                  post :create, :params => {
-                                              :activity_id => '11',
+                    :time_entry => {
-                                              :issue_id => '',
+                      :project_id => '3',
-                                              :spent_on => '2008-03-14',
+                      :activity_id => '11',
-                                              :hours => '7.3'}
+                      :issue_id => '',
+                      :spent_on => '2008-03-14',
+                      :hours => '7.3'
+                    }
+                  }
                 end
                 assert_response 403
               end
               def test_create_without_project_with_failure
                 @request.session[:user_id] = 2
                 assert_no_difference 'TimeEntry.count' do
-                  post :create, :time_entry => {:project_id => '1',
+                  post :create, :params => {
-                                              :activity_id => '11',
+                    :time_entry => {
-                                              :issue_id => '',
+                      :project_id => '1',
-                                              :spent_on => '2008-03-14',
+                      :activity_id => '11',
-                                              :hours => ''}
+                      :issue_id => '',
+                      :spent_on => '2008-03-14',
+                      :hours => ''
+                    }
+                  }
                 end
                 assert_response :success
                 assert_select 'select[name=?]', 'time_entry[project_id]' do
                   assert_select 'option[value="1"][selected=selected]'
                 end
               end
               def test_update
                 entry = TimeEntry.find(1)
                 assert_equal 1, entry.issue_id
                 assert_equal 2, entry.user_id
                 @request.session[:user_id] = 1
-                put :update, :id => 1,
+                put :update, :params => {
-                            :time_entry => {:issue_id => '2',
+                  :id => 1,
-                                            :hours => '8'}
+                  :time_entry => {
+                    :issue_id => '2',
+                    :hours => '8'
+                  }
+                }
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 entry.reload
                 assert_equal 8, entry.hours
                 assert_equal 2, entry.issue_id
                 assert_equal 2, entry.user_id
               end
               def test_update_should_allow_to_change_issue_to_another_project
                 entry = TimeEntry.generate!(:issue_id => 1)
                 @request.session[:user_id] = 1
-                put :update, :id => entry.id, :time_entry => {:issue_id => '5'}
+                put :update, :params => {
+                  :id => entry.id,
+                  :time_entry => {
+                    :issue_id => '5'
+                  }
+                }
                 assert_response 302
                 entry.reload
                 assert_equal 5, entry.issue_id
                 assert_equal 3, entry.project_id
               end
               def test_update_should_not_allow_to_change_issue_to_an_invalid_project
                 entry = TimeEntry.generate!(:issue_id => 1)
                 Project.find(3).disable_module!(:time_tracking)
                 @request.session[:user_id] = 1
-                put :update, :id => entry.id, :time_entry => {:issue_id => '5'}
+                put :update, :params => {
+                  :id => entry.id,
+                  :time_entry => {
+                    :issue_id => '5'
+                  }
+                }
                 assert_response 200
                 assert_include "Issue is invalid", assigns(:time_entry).errors.full_messages
               end
               def test_get_bulk_edit
                 @request.session[:user_id] = 2
-                get :bulk_edit, :ids => [1, 2]
+                get :bulk_edit, :params => {:ids => [1, 2]}
                 assert_response :success
                 assert_template 'bulk_edit'
                 assert_select 'ul#bulk-selection' do
                   assert_select 'li', 2
                   assert_select 'li a', :text => '03/23/2007 - eCookbook: 4.25 hours'
                 end
                 assert_select 'form#bulk_edit_form[action=?]', '/time_entries/bulk_update' do
                   # System wide custom field
                   assert_select 'select[name=?]', 'time_entry[custom_field_values][10]'
                   # Activities
                   assert_select 'select[name=?]', 'time_entry[activity_id]' do
                     assert_select 'option[value=""]', :text => '(No change)'
                     assert_select 'option[value="9"]', :text => 'Design'
                   end
                 end
               end
               def test_get_bulk_edit_on_different_projects
                 @request.session[:user_id] = 2
-                get :bulk_edit, :ids => [1, 2, 6]
+                get :bulk_edit, :params => {:ids => [1, 2, 6]}
                 assert_response :success
                 assert_template 'bulk_edit'
               end
               def test_bulk_edit_with_edit_own_time_entries_permission
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :edit_time_entries
                 Role.find_by_name('Manager').add_permission! :edit_own_time_entries
                 ids = (0..1).map {TimeEntry.generate!(:user => User.find(2)).id}
-                get :bulk_edit, :ids => ids
+                get :bulk_edit, :params => {:ids => ids}
                 assert_response :success
               end
               def test_bulk_update
                 @request.session[:user_id] = 2
                 # update time entry activity
-                post :bulk_update, :ids => [1, 2], :time_entry => { :activity_id => 9}
+                post :bulk_update, :params => {:ids => [1, 2], :time_entry => { :activity_id => 9}}
                 assert_response 302
                 # check that the issues were updated
                 assert_equal [9, 9], TimeEntry.where(:id => [1, 2]).collect {|i| i.activity_id}
               end
               def test_bulk_update_with_failure
                 @request.session[:user_id] = 2
-                post :bulk_update, :ids => [1, 2], :time_entry => { :hours => 'A'}
+                post :bulk_update, :params => {:ids => [1, 2], :time_entry => { :hours => 'A'}}
                 assert_response 302
                 assert_match /Failed to save 2 time entrie/, flash[:error]
               end
               def test_bulk_update_on_different_projects
                 @request.session[:user_id] = 2
                 # makes user a manager on the other project
                 Member.create!(:user_id => 2, :project_id => 3, :role_ids => [1])
                 # update time entry activity
-                post :bulk_update, :ids => [1, 2, 4], :time_entry => { :activity_id => 9 }
+                post :bulk_update, :params => {:ids => [1, 2, 4], :time_entry => { :activity_id => 9 }}
                 assert_response 302
                 # check that the issues were updated
                 assert_equal [9, 9, 9], TimeEntry.where(:id => [1, 2, 4]).collect {|i| i.activity_id}
               end
               def test_bulk_update_on_different_projects_without_rights
                 @request.session[:user_id] = 3
                 user = User.find(3)
                 action = { :controller => "timelog", :action => "bulk_update" }
                 assert user.allowed_to?(action, TimeEntry.find(1).project)
                 assert ! user.allowed_to?(action, TimeEntry.find(5).project)
-                post :bulk_update, :ids => [1, 5], :time_entry => { :activity_id => 9 }
+                post :bulk_update, :params => {:ids => [1, 5], :time_entry => { :activity_id => 9 }}
                 assert_response 403
               end
               def test_bulk_update_with_edit_own_time_entries_permission
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :edit_time_entries
                 Role.find_by_name('Manager').add_permission! :edit_own_time_entries
                 ids = (0..1).map {TimeEntry.generate!(:user => User.find(2)).id}
-                post :bulk_update, :ids => ids, :time_entry => { :activity_id => 9 }
+                post :bulk_update, :params => {:ids => ids, :time_entry => { :activity_id => 9 }}
                 assert_response 302
               end
               def test_bulk_update_with_edit_own_time_entries_permissions_should_be_denied_for_time_entries_of_other_user
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :edit_time_entries
                 Role.find_by_name('Manager').add_permission! :edit_own_time_entries
-                post :bulk_update, :ids => [1, 2], :time_entry => { :activity_id => 9 }
+                post :bulk_update, :params => {:ids => [1, 2], :time_entry => { :activity_id => 9 }}
                 assert_response 403
               end
               def test_bulk_update_custom_field
                 @request.session[:user_id] = 2
-                post :bulk_update, :ids => [1, 2], :time_entry => { :custom_field_values => {'10' => '0'} }
+                post :bulk_update, :params => {:ids => [1, 2], :time_entry => { :custom_field_values => {'10' => '0'} }}
                 assert_response 302
                 assert_equal ["0", "0"], TimeEntry.where(:id => [1, 2]).collect {|i| i.custom_value_for(10).value}
               end
               def test_bulk_update_clear_custom_field
                 field = TimeEntryCustomField.generate!(:field_format => 'string')
                 @request.session[:user_id] = 2
-                post :bulk_update, :ids => [1, 2], :time_entry => { :custom_field_values => {field.id.to_s => '__none__'} }
+                post :bulk_update, :params => {:ids => [1, 2], :time_entry => { :custom_field_values => {field.id.to_s => '__none__'} }}
                 assert_response 302
                 assert_equal ["", ""], TimeEntry.where(:id => [1, 2]).collect {|i| i.custom_value_for(field).value}
               end
               def test_post_bulk_update_should_redirect_back_using_the_back_url_parameter
                 @request.session[:user_id] = 2
-                post :bulk_update, :ids => [1,2], :back_url => '/time_entries'
+                post :bulk_update, :params => {:ids => [1,2], :back_url => '/time_entries'}
                 assert_response :redirect
                 assert_redirected_to '/time_entries'
               end
               def test_post_bulk_update_should_not_redirect_back_using_the_back_url_parameter_off_the_host
                 @request.session[:user_id] = 2
-                post :bulk_update, :ids => [1,2], :back_url => 'http://google.com'
+                post :bulk_update, :params => {:ids => [1,2], :back_url => 'http://google.com'}
                 assert_response :redirect
                 assert_redirected_to :controller => 'timelog', :action => 'index', :project_id => Project.find(1).identifier
               end
               def test_post_bulk_update_without_edit_permission_should_be_denied
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :edit_time_entries
-                post :bulk_update, :ids => [1,2]
+                post :bulk_update, :params => {:ids => [1,2]}
                 assert_response 403
               end
               def test_destroy
                 @request.session[:user_id] = 2
-                delete :destroy, :id => 1
+                delete :destroy, :params => {:id => 1}
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_equal I18n.t(:notice_successful_delete), flash[:notice]
                 assert_nil TimeEntry.find_by_id(1)
               end
               def test_destroy_should_fail
                 # simulate that this fails (e.g. due to a plugin), see #5700
                 TimeEntry.any_instance.expects(:destroy).returns(false)
                 @request.session[:user_id] = 2
-                delete :destroy, :id => 1
+                delete :destroy, :params => {:id => 1}
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_equal I18n.t(:notice_unable_delete_time_entry), flash[:error]
                 assert_not_nil TimeEntry.find_by_id(1)
               end
               def test_index_all_projects
                 get :index
                 assert_response :success
                 assert_select '.total-for-hours', :text => 'Hours: 162.90'
                 assert_select 'form#query_form[action=?]', '/time_entries'
               end
               def test_index_all_projects_should_show_log_time_link
                 @request.session[:user_id] = 2
                 get :index
                 assert_response :success
                 assert_template 'index'
                 assert_select 'a[href=?]', '/time_entries/new', :text => /Log time/
               end
               def test_index_my_spent_time
                 @request.session[:user_id] = 2
-                get :index, :user_id => 'me'
+                get :index, :params => {:user_id => 'me'}
                 assert_response :success
                 assert_template 'index'
                 assert assigns(:entries).all? {|entry| entry.user_id == 2}
               end
               def test_index_at_project_level
-                get :index, :project_id => 'ecookbook'
+                get :index, :params => {:project_id => 'ecookbook'}
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:entries)
                 assert_equal 4, assigns(:entries).size
                 # project and subproject
                 assert_equal [1, 3], assigns(:entries).collect(&:project_id).uniq.sort
                 assert_select '.total-for-hours', :text => 'Hours: 162.90'
                 assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries'
               end
               def test_index_with_display_subprojects_issues_to_false_should_not_include_subproject_entries
                 entry = TimeEntry.generate!(:project => Project.find(3))
                 with_settings :display_subprojects_issues => '0' do
-                  get :index, :project_id => 'ecookbook'
+                  get :index, :params => {:project_id => 'ecookbook'}
                   assert_response :success
                   assert_template 'index'
                   assert_not_include entry, assigns(:entries)
                 end
               end
               def test_index_with_display_subprojects_issues_to_false_and_subproject_filter_should_include_subproject_entries
                 entry = TimeEntry.generate!(:project => Project.find(3))
                 with_settings :display_subprojects_issues => '0' do
-                  get :index, :project_id => 'ecookbook', :subproject_id => 3
+                  get :index, :params => {:project_id => 'ecookbook', :subproject_id => 3}
                   assert_response :success
                   assert_template 'index'
                   assert_include entry, assigns(:entries)
                 end
               end
               def test_index_at_project_level_with_issue_id_short_filter
                 issue = Issue.generate!(:project_id => 1)
                 TimeEntry.generate!(:issue => issue, :hours => 4)
                 TimeEntry.generate!(:issue => issue, :hours => 3)
                 @request.session[:user_id] = 2
-                get :index, :project_id => 'ecookbook', :issue_id => issue.id.to_s, :set_filter => 1
+                get :index, :params => {:project_id => 'ecookbook', :issue_id => issue.id.to_s, :set_filter => 1}
                 assert_select '.total-for-hours', :text => 'Hours: 7.00'
               end
               def test_index_at_project_level_with_issue_fixed_version_id_short_filter
                 version = Version.generate!(:project_id => 1)
                 issue = Issue.generate!(:project_id => 1, :fixed_version => version)
                 TimeEntry.generate!(:issue => issue, :hours => 2)
                 TimeEntry.generate!(:issue => issue, :hours => 3)
                 @request.session[:user_id] = 2
-                get :index, :project_id => 'ecookbook', :"issue.fixed_version_id" => version.id.to_s, :set_filter => 1
+                get :index, :params => {:project_id => 'ecookbook', :"issue.fixed_version_id" => version.id.to_s, :set_filter => 1}
                 assert_select '.total-for-hours', :text => 'Hours: 5.00'
               end
               def test_index_at_project_level_with_date_range
-                get :index, :project_id => 'ecookbook',
+                get :index, :params => {
+                  :project_id => 'ecookbook',
                   :f => ['spent_on'],
                   :op => {'spent_on' => '><'},
                   :v => {'spent_on' => ['2007-03-20', '2007-04-30']}
+                }
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:entries)
                 assert_equal 3, assigns(:entries).size
                 assert_select '.total-for-hours', :text => 'Hours: 12.90'
                 assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries'
               end
               def test_index_at_project_level_with_date_range_using_from_and_to_params
-                get :index, :project_id => 'ecookbook', :from => '2007-03-20', :to => '2007-04-30'
+                get :index, :params => {
+                  :project_id => 'ecookbook',
+                  :from => '2007-03-20',
+                  :to => '2007-04-30'
+                }
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:entries)
                 assert_equal 3, assigns(:entries).size
                 assert_select '.total-for-hours', :text => 'Hours: 12.90'
                 assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries'
               end
               def test_index_at_project_level_with_period
-                get :index, :project_id => 'ecookbook',
+                get :index, :params => {
+                  :project_id => 'ecookbook',
                   :f => ['spent_on'],
                   :op => {'spent_on' => '>t-'},
                   :v => {'spent_on' => ['7']}
+                }
                 assert_response :success
                 assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries'
               end
               def test_index_should_sort_by_spent_on_and_created_on
                 t1 = TimeEntry.create!(:user => User.find(1), :project => Project.find(1), :hours => 1, :spent_on => '2012-06-16', :created_on => '2012-06-16 20:00:00', :activity_id => 10)
                 t2 = TimeEntry.create!(:user => User.find(1), :project => Project.find(1), :hours => 1, :spent_on => '2012-06-16', :created_on => '2012-06-16 20:05:00', :activity_id => 10)
                 t3 = TimeEntry.create!(:user => User.find(1), :project => Project.find(1), :hours => 1, :spent_on => '2012-06-15', :created_on => '2012-06-16 20:10:00', :activity_id => 10)
-                get :index, :project_id => 1,
+                get :index, :params => {
+                  :project_id => 1,
                   :f => ['spent_on'],
                   :op => {'spent_on' => '><'},
                   :v => {'spent_on' => ['2012-06-15', '2012-06-16']}
+                }
                 assert_response :success
                 assert_equal [t2, t1, t3], assigns(:entries)
-                get :index, :project_id => 1,
+                get :index, :params => {
+                  :project_id => 1,
                   :f => ['spent_on'],
                   :op => {'spent_on' => '><'},
                   :v => {'spent_on' => ['2012-06-15', '2012-06-16']},
                   :sort => 'spent_on'
+                }
                 assert_response :success
                 assert_equal [t3, t1, t2], assigns(:entries)
               end
               def test_index_with_filter_on_issue_custom_field
                 issue = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {2 => 'filter_on_issue_custom_field'})
                 entry = TimeEntry.generate!(:issue => issue, :hours => 2.5)
-                get :index, :f => ['issue.cf_2'], :op => {'issue.cf_2' => '='}, :v => {'issue.cf_2' => ['filter_on_issue_custom_field']}
+                get :index, :params => {
+                  :f => ['issue.cf_2'],
+                  :op => {'issue.cf_2' => '='},
+                  :v => {'issue.cf_2' => ['filter_on_issue_custom_field']}
+                }
                 assert_response :success
                 assert_equal [entry], assigns(:entries)
               end
               def test_index_with_issue_custom_field_column
                 issue = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {2 => 'filter_on_issue_custom_field'})
                 entry = TimeEntry.generate!(:issue => issue, :hours => 2.5)
-                get :index, :c => %w(project spent_on issue comments hours issue.cf_2)
+                get :index, :params => {
+                  :c => %w(project spent_on issue comments hours issue.cf_2)
+                }
                 assert_response :success
                 assert_include :'issue.cf_2', assigns(:query).column_names
                 assert_select 'td.issue_cf_2', :text => 'filter_on_issue_custom_field'
               end
               def test_index_with_time_entry_custom_field_column
                 field = TimeEntryCustomField.generate!(:field_format => 'string')
                 entry = TimeEntry.generate!(:hours => 2.5, :custom_field_values => {field.id => 'CF Value'})
                 field_name = "cf_#{field.id}"
-                get :index, :c => ["hours", field_name]
+                get :index, :params => {
+                  :c => ["hours", field_name]
+                }
                 assert_response :success
                 assert_include field_name.to_sym, assigns(:query).column_names
                 assert_select "td.#{field_name}", :text => 'CF Value'
               end
               def test_index_with_time_entry_custom_field_sorting
                 field = TimeEntryCustomField.generate!(:field_format => 'string', :name => 'String Field')
                 TimeEntry.generate!(:hours => 2.5, :custom_field_values => {field.id => 'CF Value 1'})
                 TimeEntry.generate!(:hours => 2.5, :custom_field_values => {field.id => 'CF Value 3'})
                 TimeEntry.generate!(:hours => 2.5, :custom_field_values => {field.id => 'CF Value 2'})
                 field_name = "cf_#{field.id}"
-                get :index, :c => ["hours", field_name], :sort => field_name
+                get :index, :params => {
+                  :c => ["hours", field_name],
+                  :sort => field_name
+                }
                 assert_response :success
                 assert_include field_name.to_sym, assigns(:query).column_names
                 assert_select "th a.sort", :text => 'String Field'
                 # Make sure that values are properly sorted
                 values = assigns(:entries).map {|e| e.custom_field_value(field)}.compact
                 assert_equal 3, values.size
                 assert_equal values.sort, values
               end
               def test_index_with_query
                 query = TimeEntryQuery.new(:project_id => 1, :name => 'Time Entry Query', :visibility => 2)
                 query.save!
                 @request.session[:user_id] = 2
-                get :index, :project_id => 'ecookbook', :query_id => query.id
+                get :index, :params => {:project_id => 'ecookbook', :query_id => query.id}
                 assert_response :success
                 assert_select 'h2', :text => query.name
                 assert_select '#sidebar a.selected', :text => query.name
               end
               def test_index_atom_feed
-                get :index, :project_id => 1, :format => 'atom'
+                get :index, :params => {:project_id => 1, :format => 'atom'}
                 assert_response :success
                 assert_equal 'application/atom+xml', @response.content_type
                 assert_not_nil assigns(:items)
                 assert assigns(:items).first.is_a?(TimeEntry)
               end
               def test_index_at_project_level_should_include_csv_export_dialog
-                get :index, :project_id => 'ecookbook',
+                get :index, :params => {
+                  :project_id => 'ecookbook',
                   :f => ['spent_on'],
                   :op => {'spent_on' => '>='},
                   :v => {'spent_on' => ['2007-04-01']},
                   :c => ['spent_on', 'user']
+                }
                 assert_response :success
                 assert_select '#csv-export-options' do
                   assert_select 'form[action=?][method=get]', '/projects/ecookbook/time_entries.csv' do
                     # filter
                     assert_select 'input[name=?][value=?]', 'f[]', 'spent_on'
                     assert_select 'input[name=?][value=?]', 'op[spent_on]', '>='
                     assert_select 'input[name=?][value=?]', 'v[spent_on][]', '2007-04-01'
                     # columns
                     assert_select 'input[name=?][value=?]', 'c[]', 'spent_on'
                     assert_select 'input[name=?][value=?]', 'c[]', 'user'
                     assert_select 'input[name=?]', 'c[]', 2
                   end
                 end
               end
               def test_index_cross_project_should_include_csv_export_dialog
                 get :index
                 assert_response :success
                 assert_select '#csv-export-options' do
                   assert_select 'form[action=?][method=get]', '/time_entries.csv'
                 end
               end
               def test_index_csv_all_projects
                 with_settings :date_format => '%m/%d/%Y' do
-                  get :index, :format => 'csv'
+                  get :index, :params => {:format => 'csv'}
                   assert_response :success
                   assert_equal 'text/csv; header=present', response.content_type
                 end
               end
               def test_index_csv
                 with_settings :date_format => '%m/%d/%Y' do
-                  get :index, :project_id => 1, :format => 'csv'
+                  get :index, :params => {:project_id => 1, :format => 'csv'}
                   assert_response :success
                   assert_equal 'text/csv; header=present', response.content_type
                 end
               end
               def test_index_csv_should_fill_issue_column_with_tracker_id_and_subject
                 issue = Issue.find(1)
                 entry = TimeEntry.generate!(:issue => issue, :comments => "Issue column content test")
-                get :index, :format => 'csv'
+                get :index, :params => {:format => 'csv'}
                 line = response.body.split("\n").detect {|l| l.include?(entry.comments)}
                 assert_not_nil line
                 assert_include "#{issue.tracker} #1: #{issue.subject}", line
               end
             end

test/functional/timelog_custom_fields_visibility_test.rb +14 -4

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class TimelogCustomFieldsVisibilityTest < Redmine::ControllerTest
               tests TimelogController
               fixtures :projects,
                        :users,
                        :roles,
                        :members,
                        :member_roles,
                        :issue_statuses,
                        :trackers,
                        :projects_trackers,
                        :enabled_modules,
                        :enumerations,
                        :workflows
               def setup
                 field_attributes = {:field_format => 'string', :is_for_all => true, :is_filter => true, :trackers => Tracker.all}
                 @fields = []
                 @fields << (@field1 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 1', :visible => true)))
                 @fields << (@field2 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 2', :visible => false, :role_ids => [1, 2])))
                 @fields << (@field3 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 3', :visible => false, :role_ids => [1, 3])))
                 @issue = Issue.generate!(
                   :author_id => 1,
                   :project_id => 1,
                   :tracker_id => 1,
                   :custom_field_values => {@field1.id => 'Value0', @field2.id => 'Value1', @field3.id => 'Value2'}
                 )
                 TimeEntry.generate!(:issue => @issue)
                 @user_with_role_on_other_project = User.generate!
                 User.add_to_project(@user_with_role_on_other_project, Project.find(2), Role.find(3))
                 @users_to_test = {
                   User.find(1) => [@field1, @field2, @field3],
                   User.find(3) => [@field1, @field2],
                   @user_with_role_on_other_project => [@field1], # should see field1 only on Project 1
                   User.generate! => [@field1],
                   User.anonymous => [@field1]
                 }
                 Member.where(:project_id => 1).each do |member|
                   member.destroy unless @users_to_test.keys.include?(member.principal)
                 end
               end
               def test_index_should_show_visible_custom_fields_only
                 @users_to_test.each do |user, fields|
                   @request.session[:user_id] = user.id
-                  get :index, :project_id => 1, :issue_id => @issue.id, :c => (['hours'] + @fields.map{|f| "issue.cf_#{f.id}"})
+                  get :index, :params => {
+                    :project_id => 1,
+                    :issue_id => @issue.id,
+                    :c => (['hours'] + @fields.map{|f| "issue.cf_#{f.id}"})
+                  }
                   @fields.each_with_index do |field, i|
                     if fields.include?(field)
                       assert_select 'td', {:text => "Value#{i}", :count => 1}, "User #{user.id} was not able to view #{field.name}"
                     else
                       assert_select 'td', {:text => "Value#{i}", :count => 0}, "User #{user.id} was able to view #{field.name}"
                     end
                   end
                 end
               end
               def test_index_as_csv_should_show_visible_custom_fields_only
                 @users_to_test.each do |user, fields|
                   @request.session[:user_id] = user.id
-                  get :index, :project_id => 1, :issue_id => @issue.id, :c => (['hours'] + @fields.map{|f| "issue.cf_#{f.id}"}), :format => 'csv'
+                  get :index, :params => {
+                    :project_id => 1,
+                    :issue_id => @issue.id,
+                    :c => (['hours'] + @fields.map{|f| "issue.cf_#{f.id}"}),
+                    :format => 'csv'
+                  }
                   @fields.each_with_index do |field, i|
                     if fields.include?(field)
                       assert_include "Value#{i}", response.body, "User #{user.id} was not able to view #{field.name} in CSV"
                     else
                       assert_not_include "Value#{i}", response.body, "User #{user.id} was able to view #{field.name} in CSV"
                     end
                   end
                 end
               end
               def test_index_with_partial_custom_field_visibility_should_show_visible_custom_fields_only
                 Issue.delete_all
                 TimeEntry.delete_all
                 p1 = Project.generate!
                 p2 = Project.generate!
                 user = User.generate!
                 User.add_to_project(user, p1, Role.where(:id => [1, 3]).to_a)
                 User.add_to_project(user, p2, Role.where(:id => 3).to_a)
                 TimeEntry.generate!(
                   :issue => Issue.generate!(:project => p1, :tracker_id => 1,
                                             :custom_field_values => {@field2.id => 'ValueA'}))
                 TimeEntry.generate!(
                   :issue => Issue.generate!(:project => p2, :tracker_id => 1,
                                             :custom_field_values => {@field2.id => 'ValueB'}))
                 TimeEntry.generate!(
                   :issue => Issue.generate!(:project => p1, :tracker_id => 1,
                                             :custom_field_values => {@field2.id => 'ValueC'}))
                 @request.session[:user_id] = user.id
-                get :index, :c => ["hours", "issue.cf_#{@field2.id}"]
+                get :index, :params => {:c => ["hours", "issue.cf_#{@field2.id}"]}
                 assert_select 'td', {:text => 'ValueA'}, "ValueA not found in:\n#{response.body}"
                 assert_select 'td', :text => 'ValueB', :count => 0
                 assert_select 'td', {:text => 'ValueC'}, "ValueC not found in:\n#{response.body}"
-                get :index, :set_filter => '1', "issue.cf_#{@field2.id}" => '*'
+                get :index, :params => {:set_filter => '1', "issue.cf_#{@field2.id}" => '*'}
                 assert_equal %w(ValueA ValueC), assigns(:entries).map{|i| i.issue.custom_field_value(@field2)}.sort
               end
             end

test/functional/trackers_controller_test.rb +61 -19

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class TrackersControllerTest < Redmine::ControllerTest
               fixtures :trackers, :projects, :projects_trackers, :users, :issues, :custom_fields, :issue_statuses
               def setup
                 User.current = nil
                 @request.session[:user_id] = 1 # admin
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
               end
               def test_index_by_anonymous_should_redirect_to_login_form
                 @request.session[:user_id] = nil
                 get :index
                 assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Ftrackers'
               end
               def test_index_by_user_should_respond_with_406
                 @request.session[:user_id] = 2
                 get :index
                 assert_response 406
               end
               def test_new
                 get :new
                 assert_response :success
                 assert_template 'new'
               end
               def test_create
                 assert_difference 'Tracker.count' do
-                  post :create, :tracker => { :name => 'New tracker', :default_status_id => 1, :project_ids => ['1', '', ''], :custom_field_ids => ['1', '6', ''] }
+                  post :create, :params => {
+                    :tracker => {
+                      :name => 'New tracker',
+                      :default_status_id => 1,
+                      :project_ids => ['1', '', ''],
+                      :custom_field_ids => ['1', '6', '']
+                    }
+                  }
                 end
                 assert_redirected_to :action => 'index'
                 tracker = Tracker.order('id DESC').first
                 assert_equal 'New tracker', tracker.name
                 assert_equal [1], tracker.project_ids.sort
                 assert_equal Tracker::CORE_FIELDS, tracker.core_fields
                 assert_equal [1, 6], tracker.custom_field_ids.sort
                 assert_equal 0, tracker.workflow_rules.count
               end
               def test_create_with_disabled_core_fields
                 assert_difference 'Tracker.count' do
-                  post :create, :tracker => { :name => 'New tracker', :default_status_id => 1, :core_fields => ['assigned_to_id', 'fixed_version_id', ''] }
+                  post :create, :params => {
+                    :tracker => {
+                      :name => 'New tracker',
+                      :default_status_id => 1,
+                      :core_fields => ['assigned_to_id', 'fixed_version_id', '']
+                    }
+                  }
                 end
                 assert_redirected_to :action => 'index'
                 tracker = Tracker.order('id DESC').first
                 assert_equal 'New tracker', tracker.name
                 assert_equal %w(assigned_to_id fixed_version_id), tracker.core_fields
               end
               def test_create_new_with_workflow_copy
                 assert_difference 'Tracker.count' do
-                  post :create, :tracker => { :name => 'New tracker', :default_status_id => 1 }, :copy_workflow_from => 1
+                  post :create, :params => {
+                    :tracker => {
+                      :name => 'New tracker',
+                      :default_status_id => 1
+                    },
+                    :copy_workflow_from => 1
+                  }
                 end
                 assert_redirected_to :action => 'index'
                 tracker = Tracker.find_by_name('New tracker')
                 assert_equal 0, tracker.projects.count
                 assert_equal Tracker.find(1).workflow_rules.count, tracker.workflow_rules.count
               end
               def test_create_with_failure
                 assert_no_difference 'Tracker.count' do
-                  post :create, :tracker => { :name => '', :project_ids => ['1', '', ''],
+                  post :create, :params => {
-                                              :custom_field_ids => ['1', '6', ''] }
+                    :tracker => {
+                      :name => '',
+                      :project_ids => ['1', '', ''],
+                      :custom_field_ids => ['1', '6', '']
+                    }
+                  }
                 end
                 assert_response :success
                 assert_template 'new'
                 assert_select_error /name cannot be blank/i
               end
               def test_edit
                 Tracker.find(1).project_ids = [1, 3]
-                get :edit, :id => 1
+                get :edit, :params => {:id => 1}
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'input[name=?][value="1"][checked=checked]', 'tracker[project_ids][]'
                 assert_select 'input[name=?][value="2"]:not([checked])', 'tracker[project_ids][]'
                 assert_select 'input[name=?][value=""][type=hidden]', 'tracker[project_ids][]'
               end
               def test_edit_should_check_core_fields
                 tracker = Tracker.find(1)
                 tracker.core_fields = %w(assigned_to_id fixed_version_id)
                 tracker.save!
-                get :edit, :id => 1
+                get :edit, :params => {:id => 1}
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'input[name=?][value=assigned_to_id][checked=checked]', 'tracker[core_fields][]'
                 assert_select 'input[name=?][value=fixed_version_id][checked=checked]', 'tracker[core_fields][]'
                 assert_select 'input[name=?][value=category_id]', 'tracker[core_fields][]'
                 assert_select 'input[name=?][value=category_id][checked=checked]', 'tracker[core_fields][]', 0
                 assert_select 'input[name=?][value=""][type=hidden]', 'tracker[core_fields][]'
               end
               def test_update
-                put :update, :id => 1, :tracker => { :name => 'Renamed',
+                put :update, :params => {
-                                                    :project_ids => ['1', '2', ''] }
+                  :id => 1,
+                  :tracker => {
+                    :name => 'Renamed',
+                    :project_ids => ['1', '2', '']
+                  }
+                }
                 assert_redirected_to :action => 'index'
                 assert_equal [1, 2], Tracker.find(1).project_ids.sort
               end
               def test_update_without_projects
-                put :update, :id => 1, :tracker => { :name => 'Renamed',
+                put :update, :params => {
-                                                    :project_ids => [''] }
+                  :id => 1,
+                  :tracker => {
+                    :name => 'Renamed',
+                    :project_ids => ['']
+                  }
+                }
                 assert_redirected_to :action => 'index'
                 assert Tracker.find(1).project_ids.empty?
               end
               def test_update_without_core_fields
-                put :update, :id => 1, :tracker => { :name => 'Renamed', :core_fields => [''] }
+                put :update, :params => {
+                  :id => 1,
+                  :tracker => {
+                    :name => 'Renamed',
+                    :core_fields => ['']
+                  }
+                }
                 assert_redirected_to :action => 'index'
                 assert Tracker.find(1).core_fields.empty?
               end
               def test_update_with_failure
-                put :update, :id => 1, :tracker => { :name => '' }
+                put :update, :params => {:id => 1, :tracker => { :name => '' }}
                 assert_response :success
                 assert_template 'edit'
                 assert_select_error /name cannot be blank/i
               end
               def test_move_lower
                tracker = Tracker.find_by_position(1)
-               put :update, :id => 1, :tracker => { :position => '2' }
+               put :update, :params => {:id => 1, :tracker => { :position => '2' }}
                assert_equal 2, tracker.reload.position
               end
               def test_destroy
                 tracker = Tracker.generate!(:name => 'Destroyable')
                 assert_difference 'Tracker.count', -1 do
-                  delete :destroy, :id => tracker.id
+                  delete :destroy, :params => {:id => tracker.id}
                 end
                 assert_redirected_to :action => 'index'
                 assert_nil flash[:error]
               end
               def test_destroy_tracker_in_use
                 assert_no_difference 'Tracker.count' do
-                  delete :destroy, :id => 1
+                  delete :destroy, :params => {:id => 1}
                 end
                 assert_redirected_to :action => 'index'
                 assert_not_nil flash[:error]
               end
               def test_get_fields
                 get :fields
                 assert_response :success
                 assert_template 'fields'
                 assert_select 'form' do
                   assert_select 'input[type=checkbox][name=?][value=assigned_to_id]', 'trackers[1][core_fields][]'
                   assert_select 'input[type=checkbox][name=?][value="2"]', 'trackers[1][custom_field_ids][]'
                   assert_select 'input[type=hidden][name=?][value=""]', 'trackers[1][core_fields][]'
                   assert_select 'input[type=hidden][name=?][value=""]', 'trackers[1][custom_field_ids][]'
                 end
               end
               def test_post_fields
-                post :fields, :trackers => {
+                post :fields, :params => {
-                  '1' => {'core_fields' => ['assigned_to_id', 'due_date', ''], 'custom_field_ids' => ['1', '2']},
+                  :trackers => {
-                  '2' => {'core_fields' => [''], 'custom_field_ids' => ['']}
+                    '1' => {'core_fields' => ['assigned_to_id', 'due_date', ''], 'custom_field_ids' => ['1', '2']},
+                    '2' => {'core_fields' => [''], 'custom_field_ids' => ['']}
+                  }
                 }
                 assert_redirected_to '/trackers/fields'
                 tracker = Tracker.find(1)
                 assert_equal %w(assigned_to_id due_date), tracker.core_fields
                 assert_equal [1, 2], tracker.custom_field_ids.sort
                 tracker = Tracker.find(2)
                 assert_equal [], tracker.core_fields
                 assert_equal [], tracker.custom_field_ids.sort
               end
             end

test/functional/versions_controller_test.rb +33 -25

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class VersionsControllerTest < Redmine::ControllerTest
               fixtures :projects, :versions, :issues, :users, :roles, :members,
                        :member_roles, :enabled_modules, :issue_statuses,
                        :issue_categories, :enumerations
               def setup
                 User.current = nil
               end
               def test_index
-                get :index, :project_id => 1
+                get :index, :params => {:project_id => 1}
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:versions)
                 # Version with no date set appears
                 assert assigns(:versions).include?(Version.find(3))
                 # Completed version doesn't appear
                 assert !assigns(:versions).include?(Version.find(1))
                 # Context menu on issues
                 assert_select "script", :text => Regexp.new(Regexp.escape("contextMenuInit('/issues/context_menu')"))
                 assert_select "div#sidebar" do
                   # Links to versions anchors
                   assert_select 'a[href=?]', '#2.0'
                   # Links to completed versions in the sidebar
                   assert_select 'a[href=?]', '/versions/1'
                 end
               end
               def test_index_with_completed_versions
-                get :index, :project_id => 1, :completed => 1
+                get :index, :params => {:project_id => 1, :completed => 1}
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:versions)
                 # Version with no date set appears
                 assert assigns(:versions).include?(Version.find(3))
                 # Completed version appears
                 assert assigns(:versions).include?(Version.find(1))
               end
               def test_index_with_tracker_ids
-                get :index, :project_id => 1, :tracker_ids => [1, 3]
+                get :index, :params => {:project_id => 1, :tracker_ids => [1, 3]}
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues_by_version)
                 assert_nil assigns(:issues_by_version).values.flatten.detect {|issue| issue.tracker_id == 2}
               end
               def test_index_showing_subprojects_versions
                 @subproject_version = Version.create!(:project => Project.find(3), :name => "Subproject version")
-                get :index, :project_id => 1, :with_subprojects => 1
+                get :index, :params => {:project_id => 1, :with_subprojects => 1}
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:versions)
                 assert assigns(:versions).include?(Version.find(4)), "Shared version not found"
                 assert assigns(:versions).include?(@subproject_version), "Subproject version not found"
               end
               def test_index_should_prepend_shared_versions
-                get :index, :project_id => 1
+                get :index, :params => {:project_id => 1}
                 assert_response :success
                 assert_select '#sidebar' do
                   assert_select 'a[href=?]', '#2.0', :text => '2.0'
                   assert_select 'a[href=?]', '#subproject1-2.0', :text => 'eCookbook Subproject 1 - 2.0'
                 end
                 assert_select '#content' do
                   assert_select 'a[name=?]', '2.0', :text => '2.0'
                   assert_select 'a[name=?]', 'subproject1-2.0', :text => 'eCookbook Subproject 1 - 2.0'
                 end
               end
               def test_show
-                get :show, :id => 2
+                get :show, :params => {:id => 2}
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:version)
                 assert_select 'h2', :text => /1.0/
               end
               def test_show_should_link_to_spent_time_on_version
                 version = Version.generate!
                 issue = Issue.generate(:fixed_version => version)
                 TimeEntry.generate!(:issue => issue, :hours => 7.2)
-                get :show, :id => version.id
+                get :show, :params => {:id => version.id}
                 assert_response :success
                 assert_select '.total-hours', :text => '7.20 hours'
                 assert_select '.total-hours a[href=?]', "/projects/ecookbook/time_entries?issue.fixed_version_id=#{version.id}&set_filter=1"
               end
               def test_show_should_display_nil_counts
                 with_settings :default_language => 'en' do
-                  get :show, :id => 2, :status_by => 'category'
+                  get :show, :params => {:id => 2, :status_by => 'category'}
                   assert_response :success
                   assert_select 'div#status_by' do
                     assert_select 'select[name=status_by]' do
                       assert_select 'option[value=category][selected=selected]'
                     end
                     assert_select 'a', :text => 'none'
                   end
                 end
               end
               def test_new
                 @request.session[:user_id] = 2
-                get :new, :project_id => '1'
+                get :new, :params => {:project_id => '1'}
                 assert_response :success
                 assert_template 'new'
               end
               def test_new_from_issue_form
                 @request.session[:user_id] = 2
-                xhr :get, :new, :project_id => '1'
+                xhr :get, :new, :params => {:project_id => '1'}
                 assert_response :success
                 assert_template 'new'
                 assert_equal 'text/javascript', response.content_type
               end
               def test_create
                 @request.session[:user_id] = 2 # manager
                 assert_difference 'Version.count' do
-                  post :create, :project_id => '1', :version => {:name => 'test_add_version'}
+                  post :create, :params => {:project_id => '1', :version => {:name => 'test_add_version'}}
                 end
                 assert_redirected_to '/projects/ecookbook/settings/versions'
                 version = Version.find_by_name('test_add_version')
                 assert_not_nil version
                 assert_equal 1, version.project_id
               end
               def test_create_from_issue_form
                 @request.session[:user_id] = 2
                 assert_difference 'Version.count' do
-                  xhr :post, :create, :project_id => '1', :version => {:name => 'test_add_version_from_issue_form'}
+                  xhr :post, :create, :params => {:project_id => '1', :version => {:name => 'test_add_version_from_issue_form'}}
                 end
                 version = Version.find_by_name('test_add_version_from_issue_form')
                 assert_not_nil version
                 assert_equal 1, version.project_id
                 assert_response :success
                 assert_template 'create'
                 assert_equal 'text/javascript', response.content_type
                 assert_include 'test_add_version_from_issue_form', response.body
               end
               def test_create_from_issue_form_with_failure
                 @request.session[:user_id] = 2
                 assert_no_difference 'Version.count' do
-                  xhr :post, :create, :project_id => '1', :version => {:name => ''}
+                  xhr :post, :create, :params => {:project_id => '1', :version => {:name => ''}}
                 end
                 assert_response :success
                 assert_template 'new'
                 assert_equal 'text/javascript', response.content_type
               end
               def test_get_edit
                 @request.session[:user_id] = 2
-                get :edit, :id => 2
+                get :edit, :params => {:id => 2}
                 assert_response :success
                 assert_template 'edit'
               end
               def test_close_completed
                 Version.update_all("status = 'open'")
                 @request.session[:user_id] = 2
-                put :close_completed, :project_id => 'ecookbook'
+                put :close_completed, :params => {:project_id => 'ecookbook'}
                 assert_redirected_to :controller => 'projects', :action => 'settings',
                                      :tab => 'versions', :id => 'ecookbook'
                 assert_not_nil Version.find_by_status('closed')
               end
               def test_post_update
                 @request.session[:user_id] = 2
-                put :update, :id => 2,
+                put :update, :params => {
-                            :version => {:name => 'New version name',
+                  :id => 2,
-                                         :effective_date => Date.today.strftime("%Y-%m-%d")}
+                  :version => {
+                    :name => 'New version name',
+                    :effective_date => Date.today.strftime("%Y-%m-%d")
+                  }
+                }
                 assert_redirected_to :controller => 'projects', :action => 'settings',
                                      :tab => 'versions', :id => 'ecookbook'
                 version = Version.find(2)
                 assert_equal 'New version name', version.name
                 assert_equal Date.today, version.effective_date
               end
               def test_post_update_with_validation_failure
                 @request.session[:user_id] = 2
-                put :update, :id => 2,
+                put :update, :params => {
-                             :version => { :name => '',
+                  :id => 2,
-                                           :effective_date => Date.today.strftime("%Y-%m-%d")}
+                  :version => {
+                    :name => '',
+                    :effective_date => Date.today.strftime("%Y-%m-%d")
+                  }
+                }
                 assert_response :success
                 assert_template 'edit'
               end
               def test_destroy
                 @request.session[:user_id] = 2
                 assert_difference 'Version.count', -1 do
-                  delete :destroy, :id => 3
+                  delete :destroy, :params => {:id => 3}
                 end
                 assert_redirected_to :controller => 'projects', :action => 'settings',
                                      :tab => 'versions', :id => 'ecookbook'
                 assert_nil Version.find_by_id(3)
               end
               def test_destroy_version_in_use_should_fail
                 @request.session[:user_id] = 2
                 assert_no_difference 'Version.count' do
-                  delete :destroy, :id => 2
+                  delete :destroy, :params => {:id => 2}
                 end
                 assert_redirected_to :controller => 'projects', :action => 'settings',
                                      :tab => 'versions', :id => 'ecookbook'
                 assert flash[:error].match(/Unable to delete version/)
                 assert Version.find_by_id(2)
               end
               def test_issue_status_by
-                xhr :get, :status_by, :id => 2
+                xhr :get, :status_by, :params => {:id => 2}
                 assert_response :success
                 assert_template 'status_by'
                 assert_template '_issue_counts'
               end
               def test_issue_status_by_status
-                xhr :get, :status_by, :id => 2, :status_by => 'status'
+                xhr :get, :status_by, :params => {:id => 2, :status_by => 'status'}
                 assert_response :success
                 assert_template 'status_by'
                 assert_template '_issue_counts'
                 assert_include 'Assigned', response.body
                 assert_include 'Closed', response.body
               end
             end

test/functional/watchers_controller_test.rb +56 -34

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class WatchersControllerTest < Redmine::ControllerTest
               fixtures :projects, :users, :roles, :members, :member_roles, :enabled_modules,
                        :issues, :trackers, :projects_trackers, :issue_statuses, :enumerations, :watchers
               def setup
                 User.current = nil
               end
               def test_watch_a_single_object
                 @request.session[:user_id] = 3
                 assert_difference('Watcher.count') do
-                  xhr :post, :watch, :object_type => 'issue', :object_id => '1'
+                  xhr :post, :watch, :params => {:object_type => 'issue', :object_id => '1'}
                   assert_response :success
                   assert_include '$(".issue-1-watcher")', response.body
                 end
                 assert Issue.find(1).watched_by?(User.find(3))
               end
               def test_watch_a_collection_with_a_single_object
                 @request.session[:user_id] = 3
                 assert_difference('Watcher.count') do
-                  xhr :post, :watch, :object_type => 'issue', :object_id => ['1']
+                  xhr :post, :watch, :params => {:object_type => 'issue', :object_id => ['1']}
                   assert_response :success
                   assert_include '$(".issue-1-watcher")', response.body
                 end
                 assert Issue.find(1).watched_by?(User.find(3))
               end
               def test_watch_a_collection_with_multiple_objects
                 @request.session[:user_id] = 3
                 assert_difference('Watcher.count', 2) do
-                  xhr :post, :watch, :object_type => 'issue', :object_id => ['1', '3']
+                  xhr :post, :watch, :params => {:object_type => 'issue', :object_id => ['1', '3']}
                   assert_response :success
                   assert_include '$(".issue-bulk-watcher")', response.body
                 end
                 assert Issue.find(1).watched_by?(User.find(3))
                 assert Issue.find(3).watched_by?(User.find(3))
               end
               def test_watch_a_news_module_should_add_watcher
                 @request.session[:user_id] = 7
                 assert_not_nil m = Project.find(1).enabled_module('news')
                 assert_difference 'Watcher.count' do
-                  xhr :post, :watch, :object_type => 'enabled_module', :object_id => m.id.to_s
+                  xhr :post, :watch, :params => {:object_type => 'enabled_module', :object_id => m.id.to_s}
                   assert_response :success
                 end
                 assert m.reload.watched_by?(User.find(7))
               end
               def test_watch_a_private_news_module_without_permission_should_fail
                 @request.session[:user_id] = 7
                 assert_not_nil m = Project.find(2).enabled_module('news')
                 assert_no_difference 'Watcher.count' do
-                  xhr :post, :watch, :object_type => 'enabled_module', :object_id => m.id.to_s
+                  xhr :post, :watch, :params => {:object_type => 'enabled_module', :object_id => m.id.to_s}
                   assert_response 403
                 end
               end
               def test_watch_should_be_denied_without_permission
                 Role.find(2).remove_permission! :view_issues
                 @request.session[:user_id] = 3
                 assert_no_difference('Watcher.count') do
-                  xhr :post, :watch, :object_type => 'issue', :object_id => '1'
+                  xhr :post, :watch, :params => {:object_type => 'issue', :object_id => '1'}
                   assert_response 403
                 end
               end
               def test_watch_invalid_class_should_respond_with_404
                 @request.session[:user_id] = 3
                 assert_no_difference('Watcher.count') do
-                  xhr :post, :watch, :object_type => 'foo', :object_id => '1'
+                  xhr :post, :watch, :params => {:object_type => 'foo', :object_id => '1'}
                   assert_response 404
                 end
               end
               def test_watch_invalid_object_should_respond_with_404
                 @request.session[:user_id] = 3
                 assert_no_difference('Watcher.count') do
-                  xhr :post, :watch, :object_type => 'issue', :object_id => '999'
+                  xhr :post, :watch, :params => {:object_type => 'issue', :object_id => '999'}
                   assert_response 404
                 end
               end
               def test_unwatch
                 @request.session[:user_id] = 3
                 assert_difference('Watcher.count', -1) do
-                  xhr :delete, :unwatch, :object_type => 'issue', :object_id => '2'
+                  xhr :delete, :unwatch, :params => {:object_type => 'issue', :object_id => '2'}
                   assert_response :success
                   assert_include '$(".issue-2-watcher")', response.body
                 end
                 assert !Issue.find(1).watched_by?(User.find(3))
               end
               def test_unwatch_a_collection_with_multiple_objects
                 @request.session[:user_id] = 3
                 Watcher.create!(:user_id => 3, :watchable => Issue.find(1))
                 Watcher.create!(:user_id => 3, :watchable => Issue.find(3))
                 assert_difference('Watcher.count', -2) do
-                  xhr :delete, :unwatch, :object_type => 'issue', :object_id => ['1', '3']
+                  xhr :delete, :unwatch, :params => {:object_type => 'issue', :object_id => ['1', '3']}
                   assert_response :success
                   assert_include '$(".issue-bulk-watcher")', response.body
                 end
                 assert !Issue.find(1).watched_by?(User.find(3))
                 assert !Issue.find(3).watched_by?(User.find(3))
               end
               def test_new
                 @request.session[:user_id] = 2
-                xhr :get, :new, :object_type => 'issue', :object_id => '2'
+                xhr :get, :new, :params => {:object_type => 'issue', :object_id => '2'}
                 assert_response :success
                 assert_match /ajax-modal/, response.body
               end
               def test_new_with_multiple_objects
                 @request.session[:user_id] = 2
-                xhr :get, :new, :object_type => 'issue', :object_id => ['1', '2']
+                xhr :get, :new, :params => {:object_type => 'issue', :object_id => ['1', '2']}
                 assert_response :success
                 assert_match /ajax-modal/, response.body
               end
               def test_new_for_new_record_with_project_id
                 @request.session[:user_id] = 2
-                xhr :get, :new, :project_id => 1
+                xhr :get, :new, :params => {:project_id => 1}
                 assert_response :success
                 assert_equal Project.find(1), assigns(:project)
                 assert_match /ajax-modal/, response.body
               end
               def test_new_for_new_record_with_project_identifier
                 @request.session[:user_id] = 2
-                xhr :get, :new, :project_id => 'ecookbook'
+                xhr :get, :new, :params => {:project_id => 'ecookbook'}
                 assert_response :success
                 assert_equal Project.find(1), assigns(:project)
                 assert_match /ajax-modal/, response.body
               end
               def test_create
                 @request.session[:user_id] = 2
                 assert_difference('Watcher.count') do
-                  xhr :post, :create, :object_type => 'issue', :object_id => '2',
+                  xhr :post, :create, :params => {
-                      :watcher => {:user_id => '4'}
+                    :object_type => 'issue', :object_id => '2',
+                    :watcher => {:user_id => '4'}
+                  }
                   assert_response :success
                   assert_match /watchers/, response.body
                   assert_match /ajax-modal/, response.body
                 end
                 assert Issue.find(2).watched_by?(User.find(4))
               end
               def test_create_with_mutiple_users
                 @request.session[:user_id] = 2
                 assert_difference('Watcher.count', 2) do
-                  xhr :post, :create, :object_type => 'issue', :object_id => '2',
+                  xhr :post, :create, :params => {
-                      :watcher => {:user_ids => ['4', '7']}
+                    :object_type => 'issue', :object_id => '2',
+                    :watcher => {:user_ids => ['4', '7']}
+                  }
                   assert_response :success
                   assert_match /watchers/, response.body
                   assert_match /ajax-modal/, response.body
                 end
                 assert Issue.find(2).watched_by?(User.find(4))
                 assert Issue.find(2).watched_by?(User.find(7))
               end
               def test_create_with_mutiple_objects
                 @request.session[:user_id] = 2
                 assert_difference('Watcher.count', 4) do
-                  xhr :post, :create, :object_type => 'issue', :object_id => ['1', '2'],
+                  xhr :post, :create, :params => {
-                      :watcher => {:user_ids => ['4', '7']}
+                    :object_type => 'issue', :object_id => ['1', '2'],
+                    :watcher => {:user_ids => ['4', '7']}
+                  }
                   assert_response :success
                   assert_match /watchers/, response.body
                   assert_match /ajax-modal/, response.body
                 end
                 assert Issue.find(1).watched_by?(User.find(4))
                 assert Issue.find(2).watched_by?(User.find(4))
                 assert Issue.find(1).watched_by?(User.find(7))
                 assert Issue.find(2).watched_by?(User.find(7))
               end
               def test_autocomplete_on_watchable_creation
                 @request.session[:user_id] = 2
-                xhr :get, :autocomplete_for_user, :q => 'mi', :project_id => 'ecookbook'
+                xhr :get, :autocomplete_for_user, :params => {:q => 'mi', :project_id => 'ecookbook'}
                 assert_response :success
                 assert_select 'input', :count => 4
                 assert_select 'input[name=?][value="1"]', 'watcher[user_ids][]'
                 assert_select 'input[name=?][value="2"]', 'watcher[user_ids][]'
                 assert_select 'input[name=?][value="8"]', 'watcher[user_ids][]'
                 assert_select 'input[name=?][value="9"]', 'watcher[user_ids][]'
               end
               def test_search_non_member_on_create
                 @request.session[:user_id] = 2
                 project = Project.find_by_name("ecookbook")
                 user = User.generate!(:firstname => 'issue15622')
                 membership = user.membership(project)
                 assert_nil membership
-                xhr :get, :autocomplete_for_user, :q => 'issue15622', :project_id => 'ecookbook'
+                xhr :get, :autocomplete_for_user, :params => {:q => 'issue15622', :project_id => 'ecookbook'}
                 assert_response :success
                 assert_select 'input', :count => 1
               end
               def test_autocomplete_on_watchable_update
                 @request.session[:user_id] = 2
-                xhr :get, :autocomplete_for_user, :q => 'mi', :object_id => '2',
+                xhr :get, :autocomplete_for_user, :params => {
-                    :object_type => 'issue', :project_id => 'ecookbook'
+                  :object_type => 'issue', :object_id => '2',
+                  :project_id => 'ecookbook', :q => 'mi'
+                }
                 assert_response :success
                 assert_select 'input', :count => 3
                 assert_select 'input[name=?][value="2"]', 'watcher[user_ids][]'
                 assert_select 'input[name=?][value="8"]', 'watcher[user_ids][]'
                 assert_select 'input[name=?][value="9"]', 'watcher[user_ids][]'
               end
               def test_search_and_add_non_member_on_update
                 @request.session[:user_id] = 2
                 project = Project.find_by_name("ecookbook")
                 user = User.generate!(:firstname => 'issue15622')
                 membership = user.membership(project)
                 assert_nil membership
-                xhr :get, :autocomplete_for_user, :q => 'issue15622', :object_id => '2',
-                    :object_type => 'issue', :project_id => 'ecookbook'
+                xhr :get, :autocomplete_for_user, :params => {
+                  :object_type => 'issue', :object_id => '2',
+                  :project_id => 'ecookbook', :q => 'issue15622'
+                }
                 assert_response :success
                 assert_select 'input', :count => 1
                 assert_difference('Watcher.count', 1) do
-                  xhr :post, :create, :object_type => 'issue', :object_id => '2',
+                  xhr :post, :create, :params => {
-                      :watcher => {:user_ids => ["#{user.id}"]}
+                    :object_type => 'issue', :object_id => '2',
+                    :watcher => {:user_ids => ["#{user.id}"]}
+                  }
                   assert_response :success
                   assert_match /watchers/, response.body
                   assert_match /ajax-modal/, response.body
                 end
                 assert Issue.find(2).watched_by?(user)
               end
               def test_autocomplete_for_user_should_return_visible_users
                 Role.update_all :users_visibility => 'members_of_visible_projects'
                 hidden = User.generate!(:lastname => 'autocomplete')
                 visible = User.generate!(:lastname => 'autocomplete')
                 User.add_to_project(visible, Project.find(1))
                 @request.session[:user_id] = 2
-                xhr :get, :autocomplete_for_user, :q => 'autocomp', :project_id => 'ecookbook'
+                xhr :get, :autocomplete_for_user, :params => {:q => 'autocomp', :project_id => 'ecookbook'}
                 assert_response :success
                 assert_include visible, assigns(:users)
                 assert_not_include hidden, assigns(:users)
               end
               def test_append
                 @request.session[:user_id] = 2
                 assert_no_difference 'Watcher.count' do
-                  xhr :post, :append, :watcher => {:user_ids => ['4', '7']}, :project_id => 'ecookbook'
+                  xhr :post, :append, :params => {
+                    :watcher => {:user_ids => ['4', '7']}, :project_id => 'ecookbook'
+                  }
                   assert_response :success
                   assert_include 'watchers_inputs', response.body
                   assert_include 'issue[watcher_user_ids][]', response.body
                 end
               end
               def test_append_without_user_should_render_nothing
                 @request.session[:user_id] = 2
-                xhr :post, :append, :project_id => 'ecookbook'
+                xhr :post, :append, :params => {:project_id => 'ecookbook'}
                 assert_response :success
                 assert response.body.blank?
               end
               def test_destroy
                 @request.session[:user_id] = 2
                 assert_difference('Watcher.count', -1) do
-                  xhr :delete, :destroy, :object_type => 'issue', :object_id => '2', :user_id => '3'
+                  xhr :delete, :destroy, :params => {
+                    :object_type => 'issue', :object_id => '2', :user_id => '3'
+                  }
                   assert_response :success
                   assert_match /watchers/, response.body
                 end
                 assert !Issue.find(2).watched_by?(User.find(3))
               end
               def test_destroy_locked_user
                 user = User.find(3)
                 user.lock!
                 assert user.reload.locked?
                 @request.session[:user_id] = 2
                 assert_difference('Watcher.count', -1) do
-                  xhr :delete, :destroy, :object_type => 'issue', :object_id => '2', :user_id => '3'
+                  xhr :delete, :destroy, :params => {
+                    :object_type => 'issue', :object_id => '2', :user_id => '3'
+                  }
                   assert_response :success
                   assert_match /watchers/, response.body
                 end
                 assert !Issue.find(2).watched_by?(User.find(3))
               end
               def test_destroy_invalid_user_should_respond_with_404
                 @request.session[:user_id] = 2
                 assert_no_difference('Watcher.count') do
-                  delete :destroy, :object_type => 'issue', :object_id => '2', :user_id => '999'
+                  delete :destroy, :params => {
+                    :object_type => 'issue', :object_id => '2', :user_id => '999'
+                  }
                   assert_response 404
                 end
               end
             end

test/functional/wiki_controller_test.rb +206 -111

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class WikiControllerTest < Redmine::ControllerTest
               fixtures :projects, :users, :email_addresses, :roles, :members, :member_roles,
                        :enabled_modules, :wikis, :wiki_pages, :wiki_contents,
                        :wiki_content_versions, :attachments,
                        :issues, :issue_statuses, :trackers
               def setup
                 User.current = nil
               end
               def test_show_start_page
-                get :show, :project_id => 'ecookbook'
+                get :show, :params => {:project_id => 'ecookbook'}
                 assert_response :success
                 assert_template 'show'
                 assert_select 'h1', :text => /CookBook documentation/
                 # child_pages macro
                 assert_select 'ul.pages-hierarchy>li>a[href=?]', '/projects/ecookbook/wiki/Page_with_an_inline_image',
                   :text => 'Page with an inline image'
               end
               def test_export_link
                 Role.anonymous.add_permission! :export_wiki_pages
-                get :show, :project_id => 'ecookbook'
+                get :show, :params => {:project_id => 'ecookbook'}
                 assert_response :success
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation.txt'
               end
               def test_show_page_with_name
-                get :show, :project_id => 1, :id => 'Another_page'
+                get :show, :params => {:project_id => 1, :id => 'Another_page'}
                 assert_response :success
                 assert_template 'show'
                 assert_select 'h1', :text => /Another page/
                 # Included page with an inline image
                 assert_select 'p', :text => /This is an inline image/
                 assert_select 'img[src=?][alt=?]', '/attachments/download/3/logo.gif', 'This is a logo'
               end
               def test_show_old_version
                 with_settings :default_language => 'en' do
-                  get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '2'
+                  get :show, :params => {:project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '2'}
                 end
                 assert_response :success
                 assert_template 'show'
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/1', :text => /Previous/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2/diff', :text => /diff/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/3', :text => /Next/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation', :text => /Current version/
               end
               def test_show_old_version_with_attachments
                 page = WikiPage.find(4)
                 assert page.attachments.any?
                 content = page.content
                 content.text = "update"
                 content.save!
-                get :show, :project_id => 'ecookbook', :id => page.title, :version => '1'
+                get :show, :params => {:project_id => 'ecookbook', :id => page.title, :version => '1'}
                 assert_kind_of WikiContent::Version, assigns(:content)
                 assert_response :success
                 assert_template 'show'
               end
               def test_show_old_version_without_permission_should_be_denied
                 Role.anonymous.remove_permission! :view_wiki_edits
-                get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '2'
+                get :show, :params => {:project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '2'}
                 assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Fprojects%2Fecookbook%2Fwiki%2FCookBook_documentation%2F2'
               end
               def test_show_first_version
                 with_settings :default_language => 'en' do
-                  get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '1'
+                  get :show, :params => {:project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '1'}
                 end
                 assert_response :success
                 assert_template 'show'
                 assert_select 'a', :text => /Previous/, :count => 0
                 assert_select 'a', :text => /diff/, :count => 0
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => /Next/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation', :text => /Current version/
               end
               def test_show_redirected_page
                 WikiRedirect.create!(:wiki_id => 1, :title => 'Old_title', :redirects_to => 'Another_page')
-                get :show, :project_id => 'ecookbook', :id => 'Old_title'
+                get :show, :params => {:project_id => 'ecookbook', :id => 'Old_title'}
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
               end
               def test_show_with_sidebar
                 page = Project.find(1).wiki.pages.new(:title => 'Sidebar')
                 page.content = WikiContent.new(:text => 'Side bar content for test_show_with_sidebar')
                 page.save!
-                get :show, :project_id => 1, :id => 'Another_page'
+                get :show, :params => {:project_id => 1, :id => 'Another_page'}
                 assert_response :success
                 assert_select 'div#sidebar', :text => /Side bar content for test_show_with_sidebar/
               end
               def test_show_should_display_section_edit_links
                 @request.session[:user_id] = 2
-                get :show, :project_id => 1, :id => 'Page with sections'
+                get :show, :params => {:project_id => 1, :id => 'Page with sections'}
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/Page_with_sections/edit?section=1', 0
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/Page_with_sections/edit?section=2'
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/Page_with_sections/edit?section=3'
               end
               def test_show_current_version_should_display_section_edit_links
                 @request.session[:user_id] = 2
-                get :show, :project_id => 1, :id => 'Page with sections', :version => 3
+                get :show, :params => {:project_id => 1, :id => 'Page with sections', :version => 3}
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/Page_with_sections/edit?section=2'
               end
               def test_show_old_version_should_not_display_section_edit_links
                 @request.session[:user_id] = 2
-                get :show, :project_id => 1, :id => 'Page with sections', :version => 2
+                get :show, :params => {:project_id => 1, :id => 'Page with sections', :version => 2}
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/Page_with_sections/edit?section=2', 0
               end
               def test_show_unexistent_page_without_edit_right
-                get :show, :project_id => 1, :id => 'Unexistent page'
+                get :show, :params => {:project_id => 1, :id => 'Unexistent page'}
                 assert_response 404
               end
               def test_show_unexistent_page_with_edit_right
                 @request.session[:user_id] = 2
-                get :show, :project_id => 1, :id => 'Unexistent page'
+                get :show, :params => {:project_id => 1, :id => 'Unexistent page'}
                 assert_response :success
                 assert_template 'edit'
               end
               def test_show_specific_version_of_an_unexistent_page_without_edit_right
-                get :show, :project_id => 1, :id => 'Unexistent page', :version => 1
+                get :show, :params => {:project_id => 1, :id => 'Unexistent page', :version => 1}
                 assert_response 404
               end
               def test_show_unexistent_page_with_parent_should_preselect_parent
                 @request.session[:user_id] = 2
-                get :show, :project_id => 1, :id => 'Unexistent page', :parent => 'Another_page'
+                get :show, :params => {:project_id => 1, :id => 'Unexistent page', :parent => 'Another_page'}
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'select[name=?] option[value="2"][selected=selected]', 'wiki_page[parent_id]'
               end
               def test_show_should_not_show_history_without_permission
                 Role.anonymous.remove_permission! :view_wiki_edits
-                get :show, :project_id => 1, :id => 'Page with sections', :version => 2
+                get :show, :params => {:project_id => 1, :id => 'Page with sections', :version => 2}
                 assert_response 302
               end
               def test_show_page_without_content_should_display_the_edit_form
                 @request.session[:user_id] = 2
                 WikiPage.create!(:title => 'NoContent', :wiki => Project.find(1).wiki)
-                get :show, :project_id => 1, :id => 'NoContent'
+                get :show, :params => {:project_id => 1, :id => 'NoContent'}
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'textarea[name=?]', 'content[text]'
               end
               def test_get_new
                 @request.session[:user_id] = 2
-                get :new, :project_id => 'ecookbook'
+                get :new, :params => {:project_id => 'ecookbook'}
                 assert_response :success
                 assert_template 'new'
               end
               def test_get_new_xhr
                 @request.session[:user_id] = 2
-                xhr :get, :new, :project_id => 'ecookbook'
+                xhr :get, :new, :params => {:project_id => 'ecookbook'}
                 assert_response :success
                 assert_template 'new'
               end
               def test_post_new_with_valid_title_should_redirect_to_edit
                 @request.session[:user_id] = 2
-                post :new, :project_id => 'ecookbook', :title => 'New Page'
+                post :new, :params => {:project_id => 'ecookbook', :title => 'New Page'}
                 assert_redirected_to '/projects/ecookbook/wiki/New_Page'
               end
               def test_post_new_xhr_with_valid_title_should_redirect_to_edit
                 @request.session[:user_id] = 2
-                xhr :post, :new, :project_id => 'ecookbook', :title => 'New Page'
+                xhr :post, :new, :params => {:project_id => 'ecookbook', :title => 'New Page'}
                 assert_response :success
                 assert_equal 'window.location = "/projects/ecookbook/wiki/New_Page"', response.body
               end
               def test_post_new_with_invalid_title_should_display_errors
                 @request.session[:user_id] = 2
-                post :new, :project_id => 'ecookbook', :title => 'Another page'
+                post :new, :params => {:project_id => 'ecookbook', :title => 'Another page'}
                 assert_response :success
                 assert_template 'new'
                 assert_select_error 'Title has already been taken'
               end
               def test_post_new_xhr_with_invalid_title_should_display_errors
                 @request.session[:user_id] = 2
-                xhr :post, :new, :project_id => 'ecookbook', :title => 'Another page'
+                xhr :post, :new, :params => {:project_id => 'ecookbook', :title => 'Another page'}
                 assert_response :success
                 assert_template 'new'
                 assert_include 'Title has already been taken', response.body
               end
               def test_create_page
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
                   assert_difference 'WikiContent.count' do
-                    put :update, :project_id => 1,
+                    put :update, :params => {
-                                :id => 'New page',
+                      :project_id => 1,
-                                :content => {:comments => 'Created the page',
+                      :id => 'New page',
-                                             :text => "h1. New page\n\nThis is a new page",
+                      :content => {
-                                             :version => 0}
+                        :comments => 'Created the page',
+                        :text => "h1. New page\n\nThis is a new page",
+                        :version => 0
+                      }
+                    }
                   end
                 end
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'New_page'
                 page = Project.find(1).wiki.find_page('New page')
                 assert !page.new_record?
                 assert_not_nil page.content
                 assert_nil page.parent
                 assert_equal 'Created the page', page.content.comments
               end
               def test_create_page_with_attachments
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
                   assert_difference 'Attachment.count' do
-                    put :update, :project_id => 1,
+                    put :update, :params => {
-                                :id => 'New page',
+                      :project_id => 1,
-                                :content => {:comments => 'Created the page',
+                      :id => 'New page',
-                                             :text => "h1. New page\n\nThis is a new page",
+                      :content => {
-                                             :version => 0},
+                        :comments => 'Created the page',
-                                :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
+                        :text => "h1. New page\n\nThis is a new page",
+                        :version => 0
+                      },
+                      :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
+                    }
                   end
                 end
                 page = Project.find(1).wiki.find_page('New page')
                 assert_equal 1, page.attachments.count
                 assert_equal 'testfile.txt', page.attachments.first.filename
               end
               def test_create_page_with_parent
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
-                  put :update, :project_id => 1, :id => 'New page',
+                  put :update, :params => {
-                    :content => {:text => "h1. New page\n\nThis is a new page", :version => 0},
+                    :project_id => 1,
+                    :id => 'New page',
+                    :content => {
+                      :text => "h1. New page\n\nThis is a new page",
+                      :version => 0
+                    },
                     :wiki_page => {:parent_id => 2}
+                  }
                 end
                 page = Project.find(1).wiki.find_page('New page')
                 assert_equal WikiPage.find(2), page.parent
               end
               def test_edit_page
                 @request.session[:user_id] = 2
-                get :edit, :project_id => 'ecookbook', :id => 'Another_page'
+                get :edit, :params => {:project_id => 'ecookbook', :id => 'Another_page'}
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'textarea[name=?]', 'content[text]',
                   :text => WikiPage.find_by_title('Another_page').content.text
               end
               def test_edit_section
                 @request.session[:user_id] = 2
-                get :edit, :project_id => 'ecookbook', :id => 'Page_with_sections', :section => 2
+                get :edit, :params => {:project_id => 'ecookbook', :id => 'Page_with_sections', :section => 2}
                 assert_response :success
                 assert_template 'edit'
                 page = WikiPage.find_by_title('Page_with_sections')
                 section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                 assert_select 'textarea[name=?]', 'content[text]', :text => section
                 assert_select 'input[name=section][type=hidden][value="2"]'
                 assert_select 'input[name=section_hash][type=hidden][value=?]', hash
               end
               def test_edit_invalid_section_should_respond_with_404
                 @request.session[:user_id] = 2
-                get :edit, :project_id => 'ecookbook', :id => 'Page_with_sections', :section => 10
+                get :edit, :params => {:project_id => 'ecookbook', :id => 'Page_with_sections', :section => 10}
                 assert_response 404
               end
               def test_update_page
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
-                      put :update, :project_id => 1,
+                      put :update, :params => {
+                        :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => "my comments",
                           :text => "edited",
                           :version => 1
                         }
+                      }
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal "edited", page.content.text
                 assert_equal 2, page.content.version
                 assert_equal "my comments", page.content.comments
               end
               def test_update_page_with_parent
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
-                      put :update, :project_id => 1,
+                      put :update, :params => {
+                        :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => "my comments",
                           :text => "edited",
                           :version => 1
                         },
                         :wiki_page => {:parent_id => '1'}
+                      }
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal "edited", page.content.text
                 assert_equal 2, page.content.version
                 assert_equal "my comments", page.content.comments
                 assert_equal WikiPage.find(1), page.parent
               end
               def test_update_page_with_failure
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
-                      put :update, :project_id => 1,
+                      put :update, :params => {
+                        :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => 'a' * 1300,  # failure here, comment is too long
                           :text => 'edited'
                         },
                         :wiki_page => {
                           :parent_id => ""
                         }
+                      }
                     end
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_select_error /Comment is too long/
                 assert_select 'textarea#content_text', :text => "edited"
                 assert_select 'input#content_version[value="1"]'
               end
               def test_update_page_with_parent_change_only_should_not_create_content_version
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
-                      put :update, :project_id => 1,
+                      put :update, :params => {
+                        :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => '',
                           :text => Wiki.find(1).find_page('Another_page').content.text,
                           :version => 1
                         },
                         :wiki_page => {:parent_id => '1'}
+                      }
                     end
                   end
                 end
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal 1, page.content.version
                 assert_equal WikiPage.find(1), page.parent
               end
               def test_update_page_with_attachments_only_should_not_create_content_version
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       assert_difference 'Attachment.count' do
-                        put :update, :project_id => 1,
+                        put :update, :params => {
+                          :project_id => 1,
                           :id => 'Another_page',
                           :content => {
                             :comments => '',
                             :text => Wiki.find(1).find_page('Another_page').content.text,
                             :version => 1
                           },
                           :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
+                        }
                       end
                     end
                   end
                 end
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal 1, page.content.version
               end
               def test_update_stale_page_should_not_raise_an_error
                 @request.session[:user_id] = 2
                 c = Wiki.find(1).find_page('Another_page').content
                 c.text = 'Previous text'
                 c.save!
                 assert_equal 2, c.version
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
-                      put :update, :project_id => 1,
+                      put :update, :params => {
+                        :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => 'My comments',
                           :text => 'Text should not be lost',
                           :version => 1
                         }
+                      }
                     end
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'div.error', :text => /Data has been updated by another user/
                 assert_select 'textarea[name=?]', 'content[text]', :text => /Text should not be lost/
                 assert_select 'input[name=?][value=?]', 'content[comments]', 'My comments'
                 c.reload
                 assert_equal 'Previous text', c.text
                 assert_equal 2, c.version
               end
               def test_update_page_without_content_should_create_content
                 @request.session[:user_id] = 2
                 page = WikiPage.create!(:title => 'NoContent', :wiki => Project.find(1).wiki)
                 assert_no_difference 'WikiPage.count' do
                   assert_difference 'WikiContent.count' do
-                    put :update, :project_id => 1, :id => 'NoContent', :content => {:text => 'Some content'}
+                    put :update, :params => {
+                      :project_id => 1,
+                      :id => 'NoContent',
+                      :content => {:text => 'Some content'}
+                    }
                     assert_response 302
                   end
                 end
                 assert_equal 'Some content', page.reload.content.text
               end
               def test_update_section
                 @request.session[:user_id] = 2
                 page = WikiPage.find_by_title('Page_with_sections')
                 section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                 text = page.content.text
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
-                      put :update, :project_id => 1, :id => 'Page_with_sections',
+                      put :update, :params => {
+                        :project_id => 1,
+                        :id => 'Page_with_sections',
                         :content => {
                           :text => "New section content",
                           :version => 3
                         },
                         :section => 2,
                         :section_hash => hash
+                      }
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Page_with_sections#section-2'
                 assert_equal Redmine::WikiFormatting::Textile::Formatter.new(text).update_section(2, "New section content"), page.reload.content.text
               end
               def test_update_section_should_allow_stale_page_update
                 @request.session[:user_id] = 2
                 page = WikiPage.find_by_title('Page_with_sections')
                 section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                 text = page.content.text
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
-                      put :update, :project_id => 1, :id => 'Page_with_sections',
+                      put :update, :params => {
+                        :project_id => 1,
+                        :id => 'Page_with_sections',
                         :content => {
                           :text => "New section content",
                           :version => 2 # Current version is 3
                         },
                         :section => 2,
                         :section_hash => hash
+                      }
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Page_with_sections#section-2'
                 page.reload
                 assert_equal Redmine::WikiFormatting::Textile::Formatter.new(text).update_section(2, "New section content"), page.content.text
                 assert_equal 4, page.content.version
               end
               def test_update_section_should_not_allow_stale_section_update
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
-                      put :update, :project_id => 1, :id => 'Page_with_sections',
+                      put :update, :params => {
+                        :project_id => 1,
+                        :id => 'Page_with_sections',
                         :content => {
                           :comments => 'My comments',
                           :text => "Text should not be lost",
                           :version => 3
                         },
                         :section => 2,
                         :section_hash => Digest::MD5.hexdigest("wrong hash")
+                      }
                     end
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'div.error', :text => /Data has been updated by another user/
                 assert_select 'textarea[name=?]', 'content[text]', :text => /Text should not be lost/
                 assert_select 'input[name=?][value=?]', 'content[comments]', 'My comments'
               end
               def test_preview
                 @request.session[:user_id] = 2
-                xhr :post, :preview, :project_id => 1, :id => 'CookBook_documentation',
+                xhr :post, :preview, :params => {
-                                               :content => { :comments => '',
+                  :project_id => 1,
-                                                             :text => 'this is a *previewed text*',
+                  :id => 'CookBook_documentation',
-                                                             :version => 3 }
+                  :content => {
+                    :comments => '',
+                    :text => 'this is a *previewed text*',
+                    :version => 3
+                  }
+                }
                 assert_response :success
                 assert_template 'common/_preview'
                 assert_select 'strong', :text => /previewed text/
               end
               def test_preview_new_page
                 @request.session[:user_id] = 2
-                xhr :post, :preview, :project_id => 1, :id => 'New page',
+                xhr :post, :preview, :params => {
-                                               :content => { :text => 'h1. New page',
+                  :project_id => 1,
-                                                             :comments => '',
+                  :id => 'New page',
-                                                             :version => 0 }
+                  :content => {
+                    :text => 'h1. New page',
+                    :comments => '',
+                    :version => 0
+                  }
+                }
                 assert_response :success
                 assert_template 'common/_preview'
                 assert_select 'h1', :text => /New page/
               end
               def test_history
                 @request.session[:user_id] = 2
-                get :history, :project_id => 'ecookbook', :id => 'CookBook_documentation'
+                get :history, :params => {:project_id => 'ecookbook', :id => 'CookBook_documentation'}
                 assert_response :success
                 assert_template 'history'
                 assert_not_nil assigns(:versions)
                 assert_equal 3, assigns(:versions).size
                 assert_select "input[type=submit][name=commit]"
                 assert_select 'td' do
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => '2'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2/annotate', :text => 'Annotate'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => 'Delete'
                 end
               end
               def test_history_with_one_version
                 @request.session[:user_id] = 2
-                get :history, :project_id => 'ecookbook', :id => 'Another_page'
+                get :history, :params => {:project_id => 'ecookbook', :id => 'Another_page'}
                 assert_response :success
                 assert_template 'history'
                 assert_not_nil assigns(:versions)
                 assert_equal 1, assigns(:versions).size
                 assert_select "input[type=submit][name=commit]", false
                 assert_select 'td' do
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1', :text => '1'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1/annotate', :text => 'Annotate'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1', :text => 'Delete', :count => 0
                 end
               end
               def test_diff
                 content = WikiPage.find(1).content
                 assert_difference 'WikiContent::Version.count', 2 do
                   content.text = "Line removed\nThis is a sample text for testing diffs"
                   content.save!
                   content.text = "This is a sample text for testing diffs\nLine added"
                   content.save!
                 end
-                get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => content.version, :version_from => (content.version - 1)
+                get :diff, :params => {
+                  :project_id => 1, :id => 'CookBook_documentation',
+                  :version => content.version,
+                  :version_from => (content.version - 1)
+                }
                 assert_response :success
                 assert_template 'diff'
                 assert_select 'span.diff_out', :text => 'Line removed'
                 assert_select 'span.diff_in', :text => 'Line added'
               end
               def test_diff_with_invalid_version_should_respond_with_404
-                get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => '99'
+                get :diff, :params => {
+                  :project_id => 1, :id => 'CookBook_documentation',
+                  :version => '99'
+                }
                 assert_response 404
               end
               def test_diff_with_invalid_version_from_should_respond_with_404
-                get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => '99', :version_from => '98'
+                get :diff, :params => {
+                  :project_id => 1, :id => 'CookBook_documentation',
+                  :version => '99',
+                  :version_from => '98'
+                }
                 assert_response 404
               end
               def test_annotate
-                get :annotate, :project_id => 1, :id =>  'CookBook_documentation', :version => 2
+                get :annotate, :params => {
+                  :project_id => 1, :id =>  'CookBook_documentation',
+                  :version => 2
+                }
                 assert_response :success
                 assert_template 'annotate'
                 # Line 1
                 assert_select 'table.annotate tr:nth-child(1)' do
                   assert_select 'th.line-num', :text => '1'
                   assert_select 'td.author', :text => /John Smith/
                   assert_select 'td', :text => /h1\. CookBook documentation/
                 end
                 # Line 5
                 assert_select 'table.annotate tr:nth-child(5)' do
                   assert_select 'th.line-num', :text => '5'
                   assert_select 'td.author', :text => /Redmine Admin/
                   assert_select 'td', :text => /Some updated \[\[documentation\]\] here/
                 end
               end
               def test_annotate_with_invalid_version_should_respond_with_404
-                get :annotate, :project_id => 1, :id => 'CookBook_documentation', :version => '99'
+                get :annotate, :params => {
+                  :project_id => 1, :id => 'CookBook_documentation',
+                  :version => '99'
+                }
                 assert_response 404
               end
               def test_get_rename
                 @request.session[:user_id] = 2
-                get :rename, :project_id => 1, :id => 'Another_page'
+                get :rename, :params => {:project_id => 1, :id => 'Another_page'}
                 assert_response :success
                 assert_template 'rename'
                 assert_select 'select[name=?]', 'wiki_page[parent_id]' do
                   assert_select 'option[value=""]', :text => ''
                   assert_select 'option[selected=selected]', 0
                 end
               end
               def test_get_rename_child_page
                 @request.session[:user_id] = 2
-                get :rename, :project_id => 1, :id => 'Child_1'
+                get :rename, :params => {:project_id => 1, :id => 'Child_1'}
                 assert_response :success
                 assert_template 'rename'
                 assert_select 'select[name=?]', 'wiki_page[parent_id]' do
                   assert_select 'option[value=""]', :text => ''
                   assert_select 'option[value="2"][selected=selected]', :text => /Another page/
                 end
               end
               def test_rename_with_redirect
                 @request.session[:user_id] = 2
-                post :rename, :project_id => 1, :id => 'Another_page',
+                post :rename, :params => {
-                                        :wiki_page => { :title => 'Another renamed page',
+                  :project_id => 1,
-                                                        :redirect_existing_links => 1 }
+                  :id => 'Another_page',
+                  :wiki_page => {
+                    :title => 'Another renamed page',
+                    :redirect_existing_links => 1
+                  }
+                }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_renamed_page'
                 wiki = Project.find(1).wiki
                 # Check redirects
                 assert_not_nil wiki.find_page('Another page')
                 assert_nil wiki.find_page('Another page', :with_redirect => false)
               end
               def test_rename_without_redirect
                 @request.session[:user_id] = 2
-                post :rename, :project_id => 1, :id => 'Another_page',
+                post :rename, :params => {
-                                        :wiki_page => { :title => 'Another renamed page',
+                  :project_id => 1,
-                                                        :redirect_existing_links => "0" }
+                  :id => 'Another_page',
+                  :wiki_page => {
+                    :title => 'Another renamed page',
+                    :redirect_existing_links => "0"
+                  }
+                }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_renamed_page'
                 wiki = Project.find(1).wiki
                 # Check that there's no redirects
                 assert_nil wiki.find_page('Another page')
               end
               def test_rename_with_parent_assignment
                 @request.session[:user_id] = 2
-                post :rename, :project_id => 1, :id => 'Another_page',
+                post :rename, :params => {
-                  :wiki_page => { :title => 'Another page', :redirect_existing_links => "0", :parent_id => '4' }
+                  :project_id => 1,
+                  :id => 'Another_page',
+                  :wiki_page => {
+                    :title => 'Another page',
+                    :redirect_existing_links => "0",
+                    :parent_id => '4'
+                  }
+                }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_page'
                 assert_equal WikiPage.find(4), WikiPage.find_by_title('Another_page').parent
               end
               def test_rename_with_parent_unassignment
                 @request.session[:user_id] = 2
-                post :rename, :project_id => 1, :id => 'Child_1',
+                post :rename, :params => {
-                  :wiki_page => { :title => 'Child 1', :redirect_existing_links => "0", :parent_id => '' }
+                  :project_id => 1,
+                  :id => 'Child_1',
+                  :wiki_page => {
+                    :title => 'Child 1',
+                    :redirect_existing_links => "0",
+                    :parent_id => ''
+                  }
+                }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Child_1'
                 assert_nil WikiPage.find_by_title('Child_1').parent
               end
               def test_get_rename_should_show_target_projects_list
                 @request.session[:user_id] = 2
                 project = Project.find(5)
                 project.enable_module! :wiki
-                get :rename, :project_id => 1, :id => 'Another_page'
+                get :rename, :params => {:project_id => 1, :id => 'Another_page'}
                 assert_response :success
                 assert_template 'rename'
                 assert_select 'select[name=?]', 'wiki_page[wiki_id]' do
                   assert_select 'option', 2
                   assert_select 'option[value=?][selected=selected]', '1', :text => /eCookbook/
                   assert_select 'option[value=?]', project.wiki.id.to_s, :text => /#{project.name}/
                 end
               end
               def test_rename_with_move
                 @request.session[:user_id] = 2
                 project = Project.find(5)
                 project.enable_module! :wiki
-                post :rename, :project_id => 1, :id => 'Another_page',
+                post :rename, :params => {
+                  :project_id => 1,
+                  :id => 'Another_page',
                   :wiki_page => {
                     :wiki_id => project.wiki.id.to_s,
                     :title => 'Another renamed page',
                     :redirect_existing_links => 1
                   }
+                }
                 assert_redirected_to '/projects/private-child/wiki/Another_renamed_page'
                 page = WikiPage.find(2)
                 assert_equal project.wiki.id, page.wiki_id
               end
               def test_destroy_a_page_without_children_should_not_ask_confirmation
                 @request.session[:user_id] = 2
-                delete :destroy, :project_id => 1, :id => 'Child_2'
+                delete :destroy, :params => {:project_id => 1, :id => 'Child_2'}
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
               end
               def test_destroy_parent_should_ask_confirmation
                 @request.session[:user_id] = 2
                 assert_no_difference('WikiPage.count') do
-                  delete :destroy, :project_id => 1, :id => 'Another_page'
+                  delete :destroy, :params => {:project_id => 1, :id => 'Another_page'}
                 end
                 assert_response :success
                 assert_template 'destroy'
                 assert_select 'form' do
                   assert_select 'input[name=todo][value=nullify]'
                   assert_select 'input[name=todo][value=destroy]'
                   assert_select 'input[name=todo][value=reassign]'
                 end
               end
               def test_destroy_parent_with_nullify_should_delete_parent_only
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -1) do
-                  delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'nullify'
+                  delete :destroy, :params => {:project_id => 1, :id => 'Another_page', :todo => 'nullify'}
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
               end
               def test_destroy_parent_with_cascade_should_delete_descendants
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -4) do
-                  delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'destroy'
+                  delete :destroy, :params => {:project_id => 1, :id => 'Another_page', :todo => 'destroy'}
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
                 assert_nil WikiPage.find_by_id(5)
               end
               def test_destroy_parent_with_reassign
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -1) do
-                  delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'reassign', :reassign_to_id => 1
+                  delete :destroy, :params => {:project_id => 1, :id => 'Another_page', :todo => 'reassign', :reassign_to_id => 1}
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
                 assert_equal WikiPage.find(1), WikiPage.find_by_id(5).parent
               end
               def test_destroy_version
                 @request.session[:user_id] = 2
                 assert_difference 'WikiContent::Version.count', -1 do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiPage.count' do
-                      delete :destroy_version, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => 2
+                      delete :destroy_version, :params => {:project_id => 'ecookbook', :id => 'CookBook_documentation', :version => 2}
                       assert_redirected_to '/projects/ecookbook/wiki/CookBook_documentation/history'
                     end
                   end
                 end
               end
               def test_destroy_invalid_version_should_respond_with_404
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiContent::Version.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiPage.count' do
-                      delete :destroy_version, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => 99
+                      delete :destroy_version, :params => {:project_id => 'ecookbook', :id => 'CookBook_documentation', :version => 99}
                     end
                   end
                 end
                 assert_response 404
               end
               def test_index
-                get :index, :project_id => 'ecookbook'
+                get :index, :params => {:project_id => 'ecookbook'}
                 assert_response :success
                 assert_template 'index'
                 pages = assigns(:pages)
                 assert_not_nil pages
                 assert_equal Project.find(1).wiki.pages.size, pages.size
                 assert_equal pages.first.content.updated_on, pages.first.updated_on
                 assert_select 'ul.pages-hierarchy' do
                   assert_select 'li' do
                     assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation', :text => 'CookBook documentation'
                     assert_select 'ul li a[href=?]', '/projects/ecookbook/wiki/Page_with_an_inline_image', :text => 'Page with an inline image'
                   end
                   assert_select 'li a[href=?]', '/projects/ecookbook/wiki/Another_page', :text => 'Another page'
                 end
               end
               def test_index_should_include_atom_link
-                get :index, :project_id => 'ecookbook'
+                get :index, :params => {:project_id => 'ecookbook'}
                 assert_select 'a[href=?]', '/projects/ecookbook/activity.atom?show_wiki_edits=1'
               end
               def test_export_to_html
                 @request.session[:user_id] = 2
-                get :export, :project_id => 'ecookbook'
+                get :export, :params => {:project_id => 'ecookbook'}
                 assert_response :success
                 assert_not_nil assigns(:pages)
                 assert assigns(:pages).any?
                 assert_equal "text/html", @response.content_type
                 assert_select "a[name=?]", "CookBook_documentation"
                 assert_select "a[name=?]", "Another_page"
                 assert_select "a[name=?]", "Page_with_an_inline_image"
               end
               def test_export_to_pdf
                 @request.session[:user_id] = 2
-                get :export, :project_id => 'ecookbook', :format => 'pdf'
+                get :export, :params => {:project_id => 'ecookbook', :format => 'pdf'}
                 assert_response :success
                 assert_not_nil assigns(:pages)
                 assert assigns(:pages).any?
                 assert_equal 'application/pdf', @response.content_type
                 assert_equal 'attachment; filename="ecookbook.pdf"', @response.headers['Content-Disposition']
                 assert @response.body.starts_with?('%PDF')
               end
               def test_export_without_permission_should_be_denied
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :export_wiki_pages
-                get :export, :project_id => 'ecookbook'
+                get :export, :params => {:project_id => 'ecookbook'}
                 assert_response 403
               end
               def test_date_index
-                get :date_index, :project_id => 'ecookbook'
+                get :date_index, :params => {:project_id => 'ecookbook'}
                 assert_response :success
                 assert_template 'date_index'
                 assert_not_nil assigns(:pages)
                 assert_not_nil assigns(:pages_by_date)
                 assert_select 'a[href=?]', '/projects/ecookbook/activity.atom?show_wiki_edits=1'
               end
               def test_not_found
-                get :show, :project_id => 999
+                get :show, :params => {:project_id => 999}
                 assert_response 404
               end
               def test_protect_page
                 page = WikiPage.find_by_wiki_id_and_title(1, 'Another_page')
                 assert !page.protected?
                 @request.session[:user_id] = 2
-                post :protect, :project_id => 1, :id => page.title, :protected => '1'
+                post :protect, :params => {:project_id => 1, :id => page.title, :protected => '1'}
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_page'
                 assert page.reload.protected?
               end
               def test_unprotect_page
                 page = WikiPage.find_by_wiki_id_and_title(1, 'CookBook_documentation')
                 assert page.protected?
                 @request.session[:user_id] = 2
-                post :protect, :project_id => 1, :id => page.title, :protected => '0'
+                post :protect, :params => {:project_id => 1, :id => page.title, :protected => '0'}
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'CookBook_documentation'
                 assert !page.reload.protected?
               end
               def test_show_page_with_edit_link
                 @request.session[:user_id] = 2
-                get :show, :project_id => 1
+                get :show, :params => {:project_id => 1}
                 assert_response :success
                 assert_template 'show'
                 assert_select 'a[href=?]', '/projects/1/wiki/CookBook_documentation/edit'
               end
               def test_show_page_without_edit_link
                 @request.session[:user_id] = 4
-                get :show, :project_id => 1
+                get :show, :params => {:project_id => 1}
                 assert_response :success
                 assert_template 'show'
                 assert_select 'a[href=?]', '/projects/1/wiki/CookBook_documentation/edit', 0
               end
               def test_show_pdf
                 @request.session[:user_id] = 2
-                get :show, :project_id => 1, :format => 'pdf'
+                get :show, :params => {:project_id => 1, :format => 'pdf'}
                 assert_response :success
                 assert_not_nil assigns(:page)
                 assert_equal 'application/pdf', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.pdf"',
                               @response.headers['Content-Disposition']
               end
               def test_show_html
                 @request.session[:user_id] = 2
-                get :show, :project_id => 1, :format => 'html'
+                get :show, :params => {:project_id => 1, :format => 'html'}
                 assert_response :success
                 assert_not_nil assigns(:page)
                 assert_equal 'text/html', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.html"',
                               @response.headers['Content-Disposition']
                 assert_select 'h1', :text => /CookBook documentation/
               end
               def test_show_versioned_html
                 @request.session[:user_id] = 2
-                get :show, :project_id => 1, :format => 'html', :version => 2
+                get :show, :params => {:project_id => 1, :format => 'html', :version => 2}
                 assert_response :success
                 assert_not_nil assigns(:content)
                 assert_equal 2, assigns(:content).version
                 assert_equal 'text/html', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.html"',
                               @response.headers['Content-Disposition']
                 assert_select 'h1', :text => /CookBook documentation/
               end
               def test_show_txt
                 @request.session[:user_id] = 2
-                get :show, :project_id => 1, :format => 'txt'
+                get :show, :params => {:project_id => 1, :format => 'txt'}
                 assert_response :success
                 assert_not_nil assigns(:page)
                 assert_equal 'text/plain', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.txt"',
                               @response.headers['Content-Disposition']
                 assert_include 'h1. CookBook documentation', @response.body
               end
               def test_show_versioned_txt
                 @request.session[:user_id] = 2
-                get :show, :project_id => 1, :format => 'txt', :version => 2
+                get :show, :params => {:project_id => 1, :format => 'txt', :version => 2}
                 assert_response :success
                 assert_not_nil assigns(:content)
                 assert_equal 2, assigns(:content).version
                 assert_equal 'text/plain', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.txt"',
                               @response.headers['Content-Disposition']
                 assert_include 'h1. CookBook documentation', @response.body
               end
               def test_edit_unprotected_page
                 # Non members can edit unprotected wiki pages
                 @request.session[:user_id] = 4
-                get :edit, :project_id => 1, :id => 'Another_page'
+                get :edit, :params => {:project_id => 1, :id => 'Another_page'}
                 assert_response :success
                 assert_template 'edit'
               end
               def test_edit_protected_page_by_nonmember
                 # Non members cannot edit protected wiki pages
                 @request.session[:user_id] = 4
-                get :edit, :project_id => 1, :id => 'CookBook_documentation'
+                get :edit, :params => {:project_id => 1, :id => 'CookBook_documentation'}
                 assert_response 403
               end
               def test_edit_protected_page_by_member
                 @request.session[:user_id] = 2
-                get :edit, :project_id => 1, :id => 'CookBook_documentation'
+                get :edit, :params => {:project_id => 1, :id => 'CookBook_documentation'}
                 assert_response :success
                 assert_template 'edit'
               end
               def test_history_of_non_existing_page_should_return_404
-                get :history, :project_id => 1, :id => 'Unknown_page'
+                get :history, :params => {:project_id => 1, :id => 'Unknown_page'}
                 assert_response 404
               end
               def test_add_attachment
                 @request.session[:user_id] = 2
                 assert_difference 'Attachment.count' do
-                  post :add_attachment, :project_id => 1, :id => 'CookBook_documentation',
+                  post :add_attachment, :params => {
-                       :attachments => {
+                    :project_id => 1,
-                         '1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'),
+                    :id => 'CookBook_documentation',
-                                 'description' => 'test file'}
+                    :attachments => {
+                      '1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}
+                    }
+                  }
                 end
                 attachment = Attachment.order('id DESC').first
                 assert_equal Wiki.find(1).find_page('CookBook_documentation'), attachment.container
               end
             end

test/functional/wikis_controller_test.rb +5 -5

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class WikisControllerTest < Redmine::ControllerTest
               fixtures :projects, :users, :roles, :members, :member_roles, :enabled_modules, :wikis
               def setup
                 User.current = nil
               end
               def test_create
                 @request.session[:user_id] = 1
                 assert_nil Project.find(3).wiki
                 assert_difference 'Wiki.count' do
-                  xhr :post, :edit, :id => 3, :wiki => { :start_page => 'Start page' }
+                  xhr :post, :edit, :params => {:id => 3, :wiki => { :start_page => 'Start page' }}
                   assert_response :success
                   assert_template 'edit'
                   assert_equal 'text/javascript', response.content_type
                 end
                 wiki = Project.find(3).wiki
                 assert_not_nil wiki
                 assert_equal 'Start page', wiki.start_page
               end
               def test_create_with_failure
                 @request.session[:user_id] = 1
                 assert_no_difference 'Wiki.count' do
-                  xhr :post, :edit, :id => 3, :wiki => { :start_page => '' }
+                  xhr :post, :edit, :params => {:id => 3, :wiki => { :start_page => '' }}
                   assert_response :success
                   assert_template 'edit'
                   assert_equal 'text/javascript', response.content_type
                 end
                 assert_include 'errorExplanation', response.body
                 assert_include "Start page cannot be blank", response.body
               end
               def test_update
                 @request.session[:user_id] = 1
                 assert_no_difference 'Wiki.count' do
-                  xhr :post, :edit, :id => 1, :wiki => { :start_page => 'Other start page' }
+                  xhr :post, :edit, :params => {:id => 1, :wiki => { :start_page => 'Other start page' }}
                   assert_response :success
                   assert_template 'edit'
                   assert_equal 'text/javascript', response.content_type
                 end
                 wiki = Project.find(1).wiki
                 assert_equal 'Other start page', wiki.start_page
               end
               def test_destroy
                 @request.session[:user_id] = 1
-                post :destroy, :id => 1, :confirm => 1
+                post :destroy, :params => {:id => 1, :confirm => 1}
                 assert_redirected_to :controller => 'projects',
                                      :action => 'settings', :id => 'ecookbook', :tab => 'wiki'
                 assert_nil Project.find(1).wiki
               end
               def test_not_found
                 @request.session[:user_id] = 1
-                post :destroy, :id => 999, :confirm => 1
+                post :destroy, :params => {:id => 999, :confirm => 1}
                 assert_response 404
               end
             end

test/functional/workflows_controller_test.rb +48 -27

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class WorkflowsControllerTest < Redmine::ControllerTest
               fixtures :roles, :trackers, :workflows, :users, :issue_statuses
               def setup
                 User.current = nil
                 @request.session[:user_id] = 1 # admin
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
                 count = WorkflowTransition.where(:role_id => 1, :tracker_id => 2).count
                 assert_select 'a[href=?]', '/workflows/edit?role_id=1&tracker_id=2', :content => count.to_s
               end
               def test_get_edit
                 get :edit
                 assert_response :success
                 assert_template 'edit'
               end
               def test_get_edit_with_role_and_tracker
                 WorkflowTransition.delete_all
                 WorkflowTransition.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 2, :new_status_id => 3)
                 WorkflowTransition.create!(:role_id => 2, :tracker_id => 1, :old_status_id => 3, :new_status_id => 5)
-                get :edit, :role_id => 2, :tracker_id => 1
+                get :edit, :params => {:role_id => 2, :tracker_id => 1}
                 assert_response :success
                 assert_template 'edit'
                 # used status only
                 assert_not_nil assigns(:statuses)
                 assert_equal [2, 3, 5], assigns(:statuses).collect(&:id)
                 # allowed transitions
                 assert_select 'input[type=checkbox][name=?][value="1"][checked=checked]', 'transitions[3][5][always]'
                 # not allowed
                 assert_select 'input[type=checkbox][name=?][value="1"]:not([checked=checked])', 'transitions[3][2][always]'
                 # unused
                 assert_select 'input[type=checkbox][name=?]', 'transitions[1][1][always]', 0
               end
               def test_get_edit_should_include_allowed_statuses_for_new_issues
                 WorkflowTransition.delete_all
                 WorkflowTransition.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 0, :new_status_id => 1)
-                get :edit, :role_id => 1, :tracker_id => 1
+                get :edit, :params => {:role_id => 1, :tracker_id => 1}
                 assert_response :success
                 assert_select 'td', 'New issue'
                 assert_select 'input[type=checkbox][name=?][value="1"][checked=checked]', 'transitions[0][1][always]'
               end
               def test_get_edit_with_all_roles_and_all_trackers
-                get :edit, :role_id => 'all', :tracker_id => 'all'
+                get :edit, :params => {:role_id => 'all', :tracker_id => 'all'}
                 assert_response :success
                 assert_equal Role.sorted.to_a, assigns(:roles)
                 assert_equal Tracker.sorted.to_a, assigns(:trackers)
               end
               def test_get_edit_with_role_and_tracker_and_all_statuses
                 WorkflowTransition.delete_all
-                get :edit, :role_id => 2, :tracker_id => 1, :used_statuses_only => '0'
+                get :edit, :params => {:role_id => 2, :tracker_id => 1, :used_statuses_only => '0'}
                 assert_response :success
                 assert_template 'edit'
                 assert_not_nil assigns(:statuses)
                 assert_equal IssueStatus.count, assigns(:statuses).size
                 assert_select 'input[type=checkbox][name=?]', 'transitions[1][1][always]'
               end
               def test_post_edit
                 WorkflowTransition.delete_all
-                post :edit, :role_id => 2, :tracker_id => 1,
+                post :edit, :params => {
+                  :role_id => 2,
+                  :tracker_id => 1,
                   :transitions => {
                     '4' => {'5' => {'always' => '1'}},
                     '3' => {'1' => {'always' => '1'}, '2' => {'always' => '1'}}
                   }
+                }
                 assert_response 302
                 assert_equal 3, WorkflowTransition.where(:tracker_id => 1, :role_id => 2).count
                 assert_not_nil  WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 3, :new_status_id => 2).first
                 assert_nil      WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 5, :new_status_id => 4).first
               end
               def test_post_edit_with_allowed_statuses_for_new_issues
                 WorkflowTransition.delete_all
-                post :edit, :role_id => 2, :tracker_id => 1,
+                post :edit, :params => {
+                  :role_id => 2,
+                  :tracker_id => 1,
                   :transitions => {
                     '0' => {'1' => {'always' => '1'}, '2' => {'always' => '1'}}
                   }
+                }
                 assert_response 302
                 assert WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 0, :new_status_id => 1).any?
                 assert WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 0, :new_status_id => 2).any?
                 assert_equal 2, WorkflowTransition.where(:tracker_id => 1, :role_id => 2).count
               end
               def test_post_edit_with_additional_transitions
                 WorkflowTransition.delete_all
-                post :edit, :role_id => 2, :tracker_id => 1,
+                post :edit, :params => {
+                  :role_id => 2,
+                  :tracker_id => 1,
                   :transitions => {
                     '4' => {'5' => {'always' => '1', 'author' => '0', 'assignee' => '0'}},
                     '3' => {'1' => {'always' => '0', 'author' => '1', 'assignee' => '0'},
                             '2' => {'always' => '0', 'author' => '0', 'assignee' => '1'},
                             '4' => {'always' => '0', 'author' => '1', 'assignee' => '1'}}
                   }
+                }
                 assert_response 302
                 assert_equal 4, WorkflowTransition.where(:tracker_id => 1, :role_id => 2).count
                 w = WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 4, :new_status_id => 5).first
                 assert ! w.author
                 assert ! w.assignee
                 w = WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 3, :new_status_id => 1).first
                 assert w.author
                 assert ! w.assignee
                 w = WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 3, :new_status_id => 2).first
                 assert ! w.author
                 assert w.assignee
                 w = WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 3, :new_status_id => 4).first
                 assert w.author
                 assert w.assignee
               end
               def test_get_permissions
                 get :permissions
                 assert_response :success
                 assert_template 'permissions'
               end
               def test_get_permissions_with_role_and_tracker
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 2, :field_name => 'assigned_to_id', :rule => 'required')
                 WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 2, :field_name => 'fixed_version_id', :rule => 'required')
                 WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 3, :field_name => 'fixed_version_id', :rule => 'readonly')
-                get :permissions, :role_id => 1, :tracker_id => 2
+                get :permissions, :params => {:role_id => 1, :tracker_id => 2}
                 assert_response :success
                 assert_template 'permissions'
                 assert_select 'input[name=?][value="1"]', 'role_id[]'
                 assert_select 'input[name=?][value="2"]', 'tracker_id[]'
                 # Required field
                 assert_select 'select[name=?]', 'permissions[2][assigned_to_id]' do
                   assert_select 'option[value=""]'
                   assert_select 'option[value=""][selected=selected]', 0
                   assert_select 'option[value=readonly]', :text => 'Read-only'
                   assert_select 'option[value=readonly][selected=selected]', 0
                   assert_select 'option[value=required]', :text => 'Required'
                   assert_select 'option[value=required][selected=selected]'
                 end
                 # Read-only field
                 assert_select 'select[name=?]', 'permissions[3][fixed_version_id]' do
                   assert_select 'option[value=""]'
                   assert_select 'option[value=""][selected=selected]', 0
                   assert_select 'option[value=readonly]', :text => 'Read-only'
                   assert_select 'option[value=readonly][selected=selected]'
                   assert_select 'option[value=required]', :text => 'Required'
                   assert_select 'option[value=required][selected=selected]', 0
                 end
                 # Other field
                 assert_select 'select[name=?]', 'permissions[3][due_date]' do
                   assert_select 'option[value=""]'
                   assert_select 'option[value=""][selected=selected]', 0
                   assert_select 'option[value=readonly]', :text => 'Read-only'
                   assert_select 'option[value=readonly][selected=selected]', 0
                   assert_select 'option[value=required]', :text => 'Required'
                   assert_select 'option[value=required][selected=selected]', 0
                 end
               end
               def test_get_permissions_with_required_custom_field_should_not_show_required_option
                 cf = IssueCustomField.create!(:name => 'Foo', :field_format => 'string', :tracker_ids => [1], :is_required => true)
-                get :permissions, :role_id => 1, :tracker_id => 1
+                get :permissions, :params => {:role_id => 1, :tracker_id => 1}
                 assert_response :success
                 assert_template 'permissions'
                 # Custom field that is always required
                 # The default option is "(Required)"
                 assert_select 'select[name=?]', "permissions[3][#{cf.id}]" do
                   assert_select 'option[value=""]'
                   assert_select 'option[value=readonly]', :text => 'Read-only'
                   assert_select 'option[value=required]', 0
                 end
               end
               def test_get_permissions_should_disable_hidden_custom_fields
                 cf1 = IssueCustomField.generate!(:tracker_ids => [1], :visible => true)
                 cf2 = IssueCustomField.generate!(:tracker_ids => [1], :visible => false, :role_ids => [1])
                 cf3 = IssueCustomField.generate!(:tracker_ids => [1], :visible => false, :role_ids => [1, 2])
-                get :permissions, :role_id => 2, :tracker_id => 1
+                get :permissions, :params => {:role_id => 2, :tracker_id => 1}
                 assert_response :success
                 assert_template 'permissions'
                 assert_select 'select[name=?]:not(.disabled)', "permissions[1][#{cf1.id}]"
                 assert_select 'select[name=?]:not(.disabled)', "permissions[1][#{cf3.id}]"
                 assert_select 'select[name=?][disabled=disabled]', "permissions[1][#{cf2.id}]" do
                   assert_select 'option[value=""][selected=selected]', :text => 'Hidden'
                 end
               end
               def test_get_permissions_with_missing_permissions_for_roles_should_default_to_no_change
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 1, :field_name => 'assigned_to_id', :rule => 'required')
-                get :permissions, :role_id => [1, 2], :tracker_id => 2
+                get :permissions, :params => {:role_id => [1, 2], :tracker_id => 2}
                 assert_response :success
                 assert_select 'select[name=?]', 'permissions[1][assigned_to_id]' do
                   assert_select 'option[selected]', 1
                   assert_select 'option[selected][value=no_change]'
                 end
               end
               def test_get_permissions_with_different_permissions_for_roles_should_default_to_no_change
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 1, :field_name => 'assigned_to_id', :rule => 'required')
                 WorkflowPermission.create!(:role_id => 2, :tracker_id => 2, :old_status_id => 1, :field_name => 'assigned_to_id', :rule => 'readonly')
-                get :permissions, :role_id => [1, 2], :tracker_id => 2
+                get :permissions, :params => {:role_id => [1, 2], :tracker_id => 2}
                 assert_response :success
                 assert_select 'select[name=?]', 'permissions[1][assigned_to_id]' do
                   assert_select 'option[selected]', 1
                   assert_select 'option[selected][value=no_change]'
                 end
               end
               def test_get_permissions_with_same_permissions_for_roles_should_default_to_permission
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 1, :field_name => 'assigned_to_id', :rule => 'required')
                 WorkflowPermission.create!(:role_id => 2, :tracker_id => 2, :old_status_id => 1, :field_name => 'assigned_to_id', :rule => 'required')
-                get :permissions, :role_id => [1, 2], :tracker_id => 2
+                get :permissions, :params => {:role_id => [1, 2], :tracker_id => 2}
                 assert_response :success
                 assert_select 'select[name=?]', 'permissions[1][assigned_to_id]' do
                   assert_select 'option[selected]', 1
                   assert_select 'option[selected][value=required]'
                 end
               end
               def test_get_permissions_with_role_and_tracker_and_all_statuses_should_show_all_statuses
                 WorkflowTransition.delete_all
-                get :permissions, :role_id => 1, :tracker_id => 2, :used_statuses_only => '0'
+                get :permissions, :params => {:role_id => 1, :tracker_id => 2, :used_statuses_only => '0'}
                 assert_response :success
                 assert_equal IssueStatus.sorted.to_a, assigns(:statuses)
               end
               def test_get_permissions_should_set_css_class
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 1, :field_name => 'assigned_to_id', :rule => 'required')
                 cf = IssueCustomField.create!(:name => 'Foo', :field_format => 'string', :tracker_ids => [2])
                 WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 1, :field_name => cf.id, :rule => 'required')
-                get :permissions, :role_id => 1, :tracker_id => 2
+                get :permissions, :params => {:role_id => 1, :tracker_id => 2}
                 assert_response :success
                 assert_select 'td.required > select[name=?]', 'permissions[1][assigned_to_id]'
                 assert_select 'td.required > select[name=?]', "permissions[1][#{cf.id}]"
               end
               def test_post_permissions
                 WorkflowPermission.delete_all
-                post :permissions, :role_id => 1, :tracker_id => 2, :permissions => {
+                post :permissions, :params => {
-                  '1' => {'assigned_to_id' => '', 'fixed_version_id' => 'required', 'due_date' => ''},
+                  :role_id => 1,
-                  '2' => {'assigned_to_id' => 'readonly', 'fixed_version_id' => 'readonly', 'due_date' => ''},
+                  :tracker_id => 2,
-                  '3' => {'assigned_to_id' => '',  'fixed_version_id' => '', 'due_date' => ''}
+                  :permissions => {
+                    '1' => {'assigned_to_id' => '', 'fixed_version_id' => 'required', 'due_date' => ''},
+                    '2' => {'assigned_to_id' => 'readonly', 'fixed_version_id' => 'readonly', 'due_date' => ''},
+                    '3' => {'assigned_to_id' => '',  'fixed_version_id' => '', 'due_date' => ''}
+                  }
                 }
                 assert_response 302
                 workflows = WorkflowPermission.all
                 assert_equal 3, workflows.size
                 workflows.each do |workflow|
                   assert_equal 1, workflow.role_id
                   assert_equal 2, workflow.tracker_id
                 end
                 assert workflows.detect {|wf| wf.old_status_id == 2 && wf.field_name == 'assigned_to_id' && wf.rule == 'readonly'}
                 assert workflows.detect {|wf| wf.old_status_id == 1 && wf.field_name == 'fixed_version_id' && wf.rule == 'required'}
                 assert workflows.detect {|wf| wf.old_status_id == 2 && wf.field_name == 'fixed_version_id' && wf.rule == 'readonly'}
               end
               def test_get_copy
                 get :copy
                 assert_response :success
                 assert_template 'copy'
                 assert_select 'select[name=source_tracker_id]' do
                   assert_select 'option[value="1"]', :text => 'Bug'
                 end
                 assert_select 'select[name=source_role_id]' do
                   assert_select 'option[value="2"]', :text => 'Developer'
                 end
                 assert_select 'select[name=?]', 'target_tracker_ids[]' do
                   assert_select 'option[value="3"]', :text => 'Support request'
                 end
                 assert_select 'select[name=?]', 'target_role_ids[]' do
                   assert_select 'option[value="1"]', :text => 'Manager'
                 end
               end
               def test_post_copy_one_to_one
                 source_transitions = status_transitions(:tracker_id => 1, :role_id => 2)
-                post :copy, :source_tracker_id => '1', :source_role_id => '2',
+                post :copy, :params => {
-                            :target_tracker_ids => ['3'], :target_role_ids => ['1']
+                  :source_tracker_id => '1', :source_role_id => '2',
+                  :target_tracker_ids => ['3'], :target_role_ids => ['1']
+                }
                 assert_response 302
                 assert_equal source_transitions, status_transitions(:tracker_id => 3, :role_id => 1)
               end
               def test_post_copy_one_to_many
                 source_transitions = status_transitions(:tracker_id => 1, :role_id => 2)
-                post :copy, :source_tracker_id => '1', :source_role_id => '2',
+                post :copy, :params => {
-                            :target_tracker_ids => ['2', '3'], :target_role_ids => ['1', '3']
+                  :source_tracker_id => '1', :source_role_id => '2',
+                  :target_tracker_ids => ['2', '3'], :target_role_ids => ['1', '3']
+                }
                 assert_response 302
                 assert_equal source_transitions, status_transitions(:tracker_id => 2, :role_id => 1)
                 assert_equal source_transitions, status_transitions(:tracker_id => 3, :role_id => 1)
                 assert_equal source_transitions, status_transitions(:tracker_id => 2, :role_id => 3)
                 assert_equal source_transitions, status_transitions(:tracker_id => 3, :role_id => 3)
               end
               def test_post_copy_many_to_many
                 source_t2 = status_transitions(:tracker_id => 2, :role_id => 2)
                 source_t3 = status_transitions(:tracker_id => 3, :role_id => 2)
-                post :copy, :source_tracker_id => 'any', :source_role_id => '2',
+                post :copy, :params => {
-                            :target_tracker_ids => ['2', '3'], :target_role_ids => ['1', '3']
+                  :source_tracker_id => 'any', :source_role_id => '2',
+                  :target_tracker_ids => ['2', '3'], :target_role_ids => ['1', '3']
+                }
                 assert_response 302
                 assert_equal source_t2, status_transitions(:tracker_id => 2, :role_id => 1)
                 assert_equal source_t3, status_transitions(:tracker_id => 3, :role_id => 1)
                 assert_equal source_t2, status_transitions(:tracker_id => 2, :role_id => 3)
                 assert_equal source_t3, status_transitions(:tracker_id => 3, :role_id => 3)
               end
               def test_post_copy_with_incomplete_source_specification_should_fail
                 assert_no_difference 'WorkflowRule.count' do
-                  post :copy,
+                  post :copy, :params => {
                     :source_tracker_id => '', :source_role_id => '2',
                     :target_tracker_ids => ['2', '3'], :target_role_ids => ['1', '3']
+                  }
                   assert_response 200
                   assert_select 'div.flash.error', :text => 'Please select a source tracker or role'
                 end
               end
               def test_post_copy_with_incomplete_target_specification_should_fail
                 assert_no_difference 'WorkflowRule.count' do
-                  post :copy,
+                  post :copy, :params => {
                     :source_tracker_id => '1', :source_role_id => '2',
                     :target_tracker_ids => ['2', '3']
+                  }
                   assert_response 200
                   assert_select 'div.flash.error', :text => 'Please select target tracker(s) and role(s)'
                 end
               end
               # Returns an array of status transitions that can be compared
               def status_transitions(conditions)
                 WorkflowTransition.
                   where(conditions).
                   order('tracker_id, role_id, old_status_id, new_status_id').
                   collect {|w| [w.old_status, w.new_status_id]}
               end
             end

test/test_helper.rb +4 -4

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             if ENV["COVERAGE"]
               require 'simplecov'
               require File.expand_path(File.dirname(__FILE__) + "/coverage/html_formatter")
               SimpleCov.formatter = Redmine::Coverage::HtmlFormatter
               SimpleCov.start 'rails'
             end
             $redmine_test_ldap_server = ENV['REDMINE_TEST_LDAP_SERVER'] || '127.0.0.1'
             ENV["RAILS_ENV"] = "test"
             require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
             require 'rails/test_help'
             require Rails.root.join('test', 'mocks', 'open_id_authentication_mock.rb').to_s
             require File.expand_path(File.dirname(__FILE__) + '/object_helpers')
             include ObjectHelpers
             require 'net/ldap'
             require 'mocha/setup'
             Redmine::SudoMode.disable!
             class ActionView::TestCase
               helper :application
               include ApplicationHelper
             end
             class ActiveSupport::TestCase
               include ActionDispatch::TestProcess
               self.use_transactional_fixtures = true
               self.use_instantiated_fixtures  = false
               def uploaded_test_file(name, mime)
                 fixture_file_upload("files/#{name}", mime, true)
               end
               # Mock out a file
               def self.mock_file
                 file = 'a_file.png'
                 file.stubs(:size).returns(32)
                 file.stubs(:original_filename).returns('a_file.png')
                 file.stubs(:content_type).returns('image/png')
                 file.stubs(:read).returns(false)
                 file
               end
               def mock_file
                 self.class.mock_file
               end
               def mock_file_with_options(options={})
                 file = ''
                 file.stubs(:size).returns(32)
                 original_filename = options[:original_filename] || nil
                 file.stubs(:original_filename).returns(original_filename)
                 content_type = options[:content_type] || nil
                 file.stubs(:content_type).returns(content_type)
                 file.stubs(:read).returns(false)
                 file
               end
               # Use a temporary directory for attachment related tests
               def set_tmp_attachments_directory
                 Dir.mkdir "#{Rails.root}/tmp/test" unless File.directory?("#{Rails.root}/tmp/test")
                 unless File.directory?("#{Rails.root}/tmp/test/attachments")
                   Dir.mkdir "#{Rails.root}/tmp/test/attachments"
                 end
                 Attachment.storage_path = "#{Rails.root}/tmp/test/attachments"
               end
               def set_fixtures_attachments_directory
                 Attachment.storage_path = "#{Rails.root}/test/fixtures/files"
               end
               def with_settings(options, &block)
                 saved_settings = options.keys.inject({}) do |h, k|
                   h[k] = case Setting[k]
                     when Symbol, false, true, nil
                       Setting[k]
                     else
                       Setting[k].dup
                     end
                   h
                 end
                 options.each {|k, v| Setting[k] = v}
                 yield
               ensure
                 saved_settings.each {|k, v| Setting[k] = v} if saved_settings
               end
               # Yields the block with user as the current user
               def with_current_user(user, &block)
                 saved_user = User.current
                 User.current = user
                 yield
               ensure
                 User.current = saved_user
               end
               def with_locale(locale, &block)
                 saved_localed = ::I18n.locale
                 ::I18n.locale = locale
                 yield
               ensure
                 ::I18n.locale = saved_localed
               end
               def self.ldap_configured?
                 @test_ldap = Net::LDAP.new(:host => $redmine_test_ldap_server, :port => 389)
                 return @test_ldap.bind
               rescue Exception => e
                 # LDAP is not listening
                 return nil
               end
               def self.convert_installed?
                 Redmine::Thumbnail.convert_available?
               end
               def convert_installed?
                 self.class.convert_installed?
               end
               # Returns the path to the test +vendor+ repository
               def self.repository_path(vendor)
                 path = Rails.root.join("tmp/test/#{vendor.downcase}_repository").to_s
                 # Unlike ruby, JRuby returns Rails.root with backslashes under Windows
                 path.tr("\\", "/")
               end
               # Returns the url of the subversion test repository
               def self.subversion_repository_url
                 path = repository_path('subversion')
                 path = '/' + path unless path.starts_with?('/')
                 "file://#{path}"
               end
               # Returns true if the +vendor+ test repository is configured
               def self.repository_configured?(vendor)
                 File.directory?(repository_path(vendor))
               end
               def repository_path_hash(arr)
                 hs = {}
                 hs[:path]  = arr.join("/")
                 hs[:param] = arr.join("/")
                 hs
               end
               def sqlite?
                 ActiveRecord::Base.connection.adapter_name =~ /sqlite/i
               end
               def mysql?
                 ActiveRecord::Base.connection.adapter_name =~ /mysql/i
               end
               def postgresql?
                 ActiveRecord::Base.connection.adapter_name =~ /postgresql/i
               end
               def quoted_date(date)
                 date = Date.parse(date) if date.is_a?(String)
                 ActiveRecord::Base.connection.quoted_date(date)
               end
               # Asserts that a new record for the given class is created
               # and returns it
               def new_record(klass, &block)
                 new_records(klass, 1, &block).first
               end
               # Asserts that count new records for the given class are created
               # and returns them as an array order by object id
               def new_records(klass, count, &block)
                 assert_difference "#{klass}.count", count do
                   yield
                 end
                 klass.order(:id => :desc).limit(count).to_a.reverse
               end
               def assert_save(object)
                 saved = object.save
                 message = "#{object.class} could not be saved"
                 errors = object.errors.full_messages.map {|m| "- #{m}"}
                 message << ":\n#{errors.join("\n")}" if errors.any?
                 assert_equal true, saved, message
               end
               def assert_select_error(arg)
                 assert_select '#errorExplanation', :text => arg
               end
               def assert_include(expected, s, message=nil)
                 assert s.include?(expected), (message || "\"#{expected}\" not found in \"#{s}\"")
               end
               def assert_not_include(expected, s, message=nil)
                 assert !s.include?(expected), (message || "\"#{expected}\" found in \"#{s}\"")
               end
               def assert_select_in(text, *args, &block)
                 d = Nokogiri::HTML(CGI::unescapeHTML(String.new(text))).root
                 assert_select(d, *args, &block)
               end
               def assert_select_email(*args, &block)
                 email = ActionMailer::Base.deliveries.last
                 assert_not_nil email
                 html_body = email.parts.detect {|part| part.content_type.include?('text/html')}.try(&:body)
                 assert_not_nil html_body
                 assert_select_in html_body.encoded, *args, &block
               end
               def assert_mail_body_match(expected, mail, message=nil)
                 if expected.is_a?(String)
                   assert_include expected, mail_body(mail), message
                 else
                   assert_match expected, mail_body(mail), message
                 end
               end
               def assert_mail_body_no_match(expected, mail, message=nil)
                 if expected.is_a?(String)
                   assert_not_include expected, mail_body(mail), message
                 else
                   assert_no_match expected, mail_body(mail), message
                 end
               end
               def mail_body(mail)
                 mail.parts.first.body.encoded
               end
               # Returns the lft value for a new root issue
               def new_issue_lft
               end
             end
             module Redmine
               class RoutingTest < ActionDispatch::IntegrationTest
                 def should_route(arg)
                   arg = arg.dup
                   request = arg.keys.detect {|key| key.is_a?(String)}
                   raise ArgumentError unless request
                   options = arg.slice!(request)
                   raise ArgumentError unless request =~ /\A(GET|POST|PUT|PATCH|DELETE)\s+(.+)\z/
                   method, path = $1.downcase.to_sym, $2
                   raise ArgumentError unless arg.values.first =~ /\A(.+)#(.+)\z/
                   controller, action = $1, $2
                   assert_routing(
                     {:method => method, :path => path},
                     options.merge(:controller => controller, :action => action)
                   )
                 end
               end
               class ControllerTest < ActionController::TestCase
-                def process(method, path, parameters={}, options={}, flash={})
+                def process(method, path, parameters={}, session={}, flash={})
-                  if parameters.key?(:params)
+                  if parameters.key?(:params) || parameters.key?(:session)
-                    raise ArgumentError if options.present?
+                    raise ArgumentError if session.present?
-                    super method, path, parameters[:params], parameters.except(:params)
+                    super method, path, parameters[:params], parameters[:session], parameters.except(:params, :session)
                   else
                     super
                   end
                 end
               end
               class IntegrationTest < ActionDispatch::IntegrationTest
                 def log_user(login, password)
                   User.anonymous
                   get "/login"
                   assert_equal nil, session[:user_id]
                   assert_response :success
                   assert_template "account/login"
                   post "/login", :username => login, :password => password
                   assert_equal login, User.find(session[:user_id]).login
                 end
                 def credentials(user, password=nil)
                   {'HTTP_AUTHORIZATION' => ActionController::HttpAuthentication::Basic.encode_credentials(user, password || user)}
                 end
               end
               module ApiTest
                 API_FORMATS = %w(json xml).freeze
                 # Base class for API tests
                 class Base < Redmine::IntegrationTest
                   def setup
                     Setting.rest_api_enabled = '1'
                   end
                   def teardown
                     Setting.rest_api_enabled = '0'
                   end
                   # Uploads content using the XML API and returns the attachment token
                   def xml_upload(content, credentials)
                     upload('xml', content, credentials)
                   end
                   # Uploads content using the JSON API and returns the attachment token
                   def json_upload(content, credentials)
                     upload('json', content, credentials)
                   end
                   def upload(format, content, credentials)
                     set_tmp_attachments_directory
                     assert_difference 'Attachment.count' do
                       post "/uploads.#{format}", content, {"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials)
                       assert_response :created
                     end
                     data = response_data
                     assert_kind_of Hash, data['upload']
                     token = data['upload']['token']
                     assert_not_nil token
                     token
                   end
                   # Parses the response body based on its content type
                   def response_data
                     unless response.content_type.to_s =~ /^application\/(.+)/
                       raise "Unexpected response type: #{response.content_type}"
                     end
                     format = $1
                     case format
                     when 'xml'
                       Hash.from_xml(response.body)
                     when 'json'
                       ActiveSupport::JSON.decode(response.body)
                     else
                       raise "Unknown response format: #{format}"
                     end
                   end
                 end
                 class Routing < Redmine::RoutingTest
                   def should_route(arg)
                     arg = arg.dup
                     request = arg.keys.detect {|key| key.is_a?(String)}
                     raise ArgumentError unless request
                     options = arg.slice!(request)
                     API_FORMATS.each do |format|
                       format_request = request.sub /$/, ".#{format}"
                       super options.merge(format_request => arg[request], :format => format)
                     end
                   end
                 end
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages