jro_apps/redmine Commit - r15282:c364e6ee9b2e

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

Jean-Philippe Lang -

r15282:c364e6ee9b2e

parent child

Context file:

r15282:c364e6ee9b2e

Collapse all files

test/functional/users_controller_test.rb +98 -52

             # 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 UsersControllerTest < Redmine::ControllerTest
               include Redmine::I18n
               fixtures :users, :email_addresses, :projects, :members, :member_roles, :roles,
                        :custom_fields, :custom_values, :groups_users,
                        :auth_sources,
                        :enabled_modules,
                        :issues, :issue_statuses,
                        :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(:users)
                 # active users only
                 assert_nil assigns(:users).detect {|u| !u.active?}
               end
               def test_index_with_status_filter
-                get :index, :status => 3
+                get :index, :params => {:status => 3}
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:users)
                 assert_equal [3], assigns(:users).map(&:status).uniq
               end
               def test_index_with_name_filter
-                get :index, :name => 'john'
+                get :index, :params => {:name => 'john'}
                 assert_response :success
                 assert_template 'index'
                 users = assigns(:users)
                 assert_not_nil users
                 assert_equal 1, users.size
                 assert_equal 'John', users.first.firstname
               end
               def test_index_with_group_filter
-                get :index, :group_id => '10'
+                get :index, :params => {:group_id => '10'}
                 assert_response :success
                 assert_template 'index'
                 users = assigns(:users)
                 assert users.any?
                 assert_equal([], (users - Group.find(10).users))
                 assert_select 'select[name=group_id]' do
                   assert_select 'option[value="10"][selected=selected]'
                 end
               end
               def test_show
                 @request.session[:user_id] = nil
-                get :show, :id => 2
+                get :show, :params => {:id => 2}
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:user)
                 assert_select 'li', :text => /Phone number/
               end
               def test_show_should_not_display_hidden_custom_fields
                 @request.session[:user_id] = nil
                 UserCustomField.find_by_name('Phone number').update_attribute :visible, false
-                get :show, :id => 2
+                get :show, :params => {:id => 2}
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:user)
                 assert_select 'li', :text => /Phone number/, :count => 0
               end
               def test_show_should_not_fail_when_custom_values_are_nil
                 user = User.find(2)
                 # Create a custom field to illustrate the issue
                 custom_field = CustomField.create!(:name => 'Testing', :field_format => 'text')
                 custom_value = user.custom_values.build(:custom_field => custom_field).save!
-                get :show, :id => 2
+                get :show, :params => {:id => 2}
                 assert_response :success
               end
               def test_show_inactive
                 @request.session[:user_id] = nil
-                get :show, :id => 5
+                get :show, :params => {:id => 5}
                 assert_response 404
               end
               def test_show_inactive_by_admin
                 @request.session[:user_id] = 1
-                get :show, :id => 5
+                get :show, :params => {:id => 5}
                 assert_response 200
                 assert_not_nil assigns(:user)
               end
               def test_show_user_who_is_not_visible_should_return_404
                 Role.anonymous.update! :users_visibility => 'members_of_visible_projects'
                 user = User.generate!
                 @request.session[:user_id] = nil
-                get :show, :id => user.id
+                get :show, :params => {:id => user.id}
                 assert_response 404
               end
               def test_show_displays_memberships_based_on_project_visibility
                 @request.session[:user_id] = 1
-                get :show, :id => 2
+                get :show, :params => {:id => 2}
                 assert_response :success
                 memberships = assigns(:memberships)
                 assert_not_nil memberships
                 project_ids = memberships.map(&:project_id)
                 assert project_ids.include?(2) #private project admin can see
               end
               def test_show_current_should_require_authentication
                 @request.session[:user_id] = nil
-                get :show, :id => 'current'
+                get :show, :params => {:id => 'current'}
                 assert_response 302
               end
               def test_show_current
                 @request.session[:user_id] = 2
-                get :show, :id => 'current'
+                get :show, :params => {:id => 'current'}
                 assert_response :success
                 assert_template 'show'
                 assert_equal User.find(2), assigns(:user)
               end
               def test_new
                 get :new
                 assert_response :success
                 assert_template :new
                 assert assigns(:user)
               end
               def test_create
                 Setting.bcc_recipients = '1'
                 assert_difference 'User.count' do
                   assert_difference 'ActionMailer::Base.deliveries.size' do
-                    post :create,
+                    post :create, :params => {
                       :user => {
                         :firstname => 'John',
                         :lastname => 'Doe',
                         :login => 'jdoe',
                         :password => 'secret123',
                         :password_confirmation => 'secret123',
                         :mail => 'jdoe@gmail.com',
                         :mail_notification => 'none'
                       },
                       :send_information => '1'
+                    }
                   end
                 end
                 user = User.order('id DESC').first
                 assert_redirected_to :controller => 'users', :action => 'edit', :id => user.id
                 assert_equal 'John', user.firstname
                 assert_equal 'Doe', user.lastname
                 assert_equal 'jdoe', user.login
                 assert_equal 'jdoe@gmail.com', user.mail
                 assert_equal 'none', user.mail_notification
                 assert user.check_password?('secret123')
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert_equal [user.mail], mail.bcc
                 assert_mail_body_match 'secret', mail
               end
               def test_create_with_preferences
                 assert_difference 'User.count' do
-                  post :create,
+                  post :create, :params => {
                     :user => {
                       :firstname => 'John',
                       :lastname => 'Doe',
                       :login => 'jdoe',
                       :password => 'secret123',
                       :password_confirmation => 'secret123',
                       :mail => 'jdoe@gmail.com',
                       :mail_notification => 'none'
                     },
                     :pref => {
                       'hide_mail' => '1',
                       'time_zone' => 'Paris',
                       'comments_sorting' => 'desc',
                       'warn_on_leaving_unsaved' => '0'
                     }
+                  }
                 end
                 user = User.order('id DESC').first
                 assert_equal 'jdoe', user.login
                 assert_equal true, user.pref.hide_mail
                 assert_equal 'Paris', user.pref.time_zone
                 assert_equal 'desc', user.pref[:comments_sorting]
                 assert_equal '0', user.pref[:warn_on_leaving_unsaved]
               end
               def test_create_with_generate_password_should_email_the_password
                 assert_difference 'User.count' do
-                  post :create, :user => {
+                  post :create, :params => {
+                    :user => {
                       :login => 'randompass',
                       :firstname => 'Random',
                       :lastname => 'Pass',
                       :mail => 'randompass@example.net',
                       :language => 'en',
                       :generate_password => '1',
                       :password => '',
                       :password_confirmation => ''
-                  }, :send_information => 1
+                    },
+                    :send_information => 1
+                  }
                 end
                 user = User.order('id DESC').first
                 assert_equal 'randompass', user.login
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 m = mail_body(mail).match(/Password: ([a-zA-Z0-9]+)/)
                 assert m
                 password = m[1]
                 assert user.check_password?(password)
               end
               def test_create_and_continue
-                post :create, :user => {
+                post :create, :params => {
+                  :user => {
                     :login => 'randompass',
                     :firstname => 'Random',
                     :lastname => 'Pass',
                     :mail => 'randompass@example.net',
                     :generate_password => '1'
-                  }, :continue => '1'
+                  },
+                  :continue => '1'
+                }
                 assert_redirected_to '/users/new?user%5Bgenerate_password%5D=1'
               end
               def test_create_with_failure
                 assert_no_difference 'User.count' do
-                  post :create, :user => {}
+                  post :create, :params => {:user => {}}
                 end
                 assert_response :success
                 assert_template 'new'
               end
               def test_create_with_failure_sould_preserve_preference
                 assert_no_difference 'User.count' do
-                  post :create,
+                  post :create, :params => {
                     :user => {},
                     :pref => {
                       'no_self_notified' => '1',
                       'hide_mail' => '1',
                       'time_zone' => 'Paris',
                       'comments_sorting' => 'desc',
                       'warn_on_leaving_unsaved' => '0'
                     }
+                  }
                 end
                 assert_response :success
                 assert_template 'new'
                 assert_select 'select#pref_time_zone option[selected=selected]', :text => /Paris/
                 assert_select 'input#pref_no_self_notified[value="1"][checked=checked]'
               end
               def test_create_admin_should_send_security_notification
                 ActionMailer::Base.deliveries.clear
-                post :create,
+                post :create, :params => {
                   :user => {
                     :firstname => 'Edgar',
                     :lastname => 'Schmoe',
                     :login => 'eschmoe',
                     :password => 'secret123',
                     :password_confirmation => 'secret123',
                     :mail => 'eschmoe@example.foo',
                     :admin => '1'
                   }
+                }
                 assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                 assert_mail_body_match '0.0.0.0', mail
                 assert_mail_body_match I18n.t(:mail_body_security_notification_add, field: I18n.t(:field_admin), value: 'eschmoe'), mail
                 assert_select_email do
                   assert_select 'a[href^=?]', 'http://localhost:3000/users', :text => 'Users'
                 end
                 # All admins should receive this
                 User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                   assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                 end
               end
               def test_create_non_admin_should_not_send_security_notification
                 ActionMailer::Base.deliveries.clear
-                post :create,
+                post :create, :params => {
                   :user => {
                     :firstname => 'Edgar',
                     :lastname => 'Schmoe',
                     :login => 'eschmoe',
                     :password => 'secret123',
                     :password_confirmation => 'secret123',
                     :mail => 'eschmoe@example.foo',
                     :admin => '0'
                   }
+                }
                 assert_nil ActionMailer::Base.deliveries.last
               end
               def test_edit
-                get :edit, :id => 2
+                get :edit, :params => {:id => 2}
                 assert_response :success
                 assert_template 'edit'
                 assert_equal User.find(2), assigns(:user)
               end
               def test_edit_registered_user
                 assert User.find(2).register!
-                get :edit, :id => 2
+                get :edit, :params => {:id => 2}
                 assert_response :success
                 assert_select 'a', :text => 'Activate'
               end
               def test_update
                 ActionMailer::Base.deliveries.clear
-                put :update, :id => 2,
+                put :update, :params => {
+                  :id => 2,
                   :user => {:firstname => 'Changed', :mail_notification => 'only_assigned'},
                   :pref => {:hide_mail => '1', :comments_sorting => 'desc'}
+                }
                 user = User.find(2)
                 assert_equal 'Changed', user.firstname
                 assert_equal 'only_assigned', user.mail_notification
                 assert_equal true, user.pref[:hide_mail]
                 assert_equal 'desc', user.pref[:comments_sorting]
                 assert ActionMailer::Base.deliveries.empty?
               end
               def test_update_with_failure
                 assert_no_difference 'User.count' do
-                  put :update, :id => 2, :user => {:firstname => ''}
+                  put :update, :params => {
+                    :id => 2,
+                    :user => {:firstname => ''}
+                  }
                 end
                 assert_response :success
                 assert_template 'edit'
               end
               def test_update_with_group_ids_should_assign_groups
-                put :update, :id => 2, :user => {:group_ids => ['10']}
+                put :update, :params => {
+                  :id => 2,
+                  :user => {:group_ids => ['10']}
+                }
                 user = User.find(2)
                 assert_equal [10], user.group_ids
               end
               def test_update_with_activation_should_send_a_notification
                 u = User.new(:firstname => 'Foo', :lastname => 'Bar', :mail => 'foo.bar@somenet.foo', :language => 'fr')
                 u.login = 'foo'
                 u.status = User::STATUS_REGISTERED
                 u.save!
                 ActionMailer::Base.deliveries.clear
                 Setting.bcc_recipients = '1'
-                put :update, :id => u.id, :user => {:status => User::STATUS_ACTIVE}
+                put :update, :params => {
+                  :id => u.id,
+                  :user => {:status => User::STATUS_ACTIVE}
+                }
                 assert u.reload.active?
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert_equal ['foo.bar@somenet.foo'], mail.bcc
                 assert_mail_body_match ll('fr', :notice_account_activated), mail
               end
               def test_update_with_password_change_should_send_a_notification
                 ActionMailer::Base.deliveries.clear
                 Setting.bcc_recipients = '1'
-                put :update, :id => 2, :user => {:password => 'newpass123', :password_confirmation => 'newpass123'}, :send_information => '1'
+                put :update, :params => {
+                  :id => 2,
+                  :user => {:password => 'newpass123', :password_confirmation => 'newpass123'},
+                  :send_information => '1'
+                }
                 u = User.find(2)
                 assert u.check_password?('newpass123')
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert_equal [u.mail], mail.bcc
                 assert_mail_body_match 'newpass123', mail
               end
               def test_update_with_generate_password_should_email_the_password
                 ActionMailer::Base.deliveries.clear
                 Setting.bcc_recipients = '1'
-                put :update, :id => 2, :user => {
+                put :update, :params => {
+                  :id => 2,
+                  :user => {
                     :generate_password => '1',
                     :password => '',
                     :password_confirmation => ''
-                }, :send_information => '1'
+                  },
+                  :send_information => '1'
+                }
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 m = mail_body(mail).match(/Password: ([a-zA-Z0-9]+)/)
                 assert m
                 password = m[1]
                 assert User.find(2).check_password?(password)
               end
               def test_update_without_generate_password_should_not_change_password
-                put :update, :id => 2, :user => {
+                put :update, :params => {
+                  :id => 2, :user => {
                     :firstname => 'changed',
                     :generate_password => '0',
                     :password => '',
                     :password_confirmation => ''
-                }, :send_information => '1'
+                  },
+                  :send_information => '1'
+                }
                 user = User.find(2)
                 assert_equal 'changed', user.firstname
                 assert user.check_password?('jsmith')
               end
               def test_update_user_switchin_from_auth_source_to_password_authentication
                 # Configure as auth source
                 u = User.find(2)
                 u.auth_source = AuthSource.find(1)
                 u.save!
-                put :update, :id => u.id, :user => {:auth_source_id => '', :password => 'newpass123', :password_confirmation => 'newpass123'}
+                put :update, :params => {
+                  :id => u.id,
+                  :user => {:auth_source_id => '', :password => 'newpass123', :password_confirmation => 'newpass123'}
+                }
                 assert_equal nil, u.reload.auth_source
                 assert u.check_password?('newpass123')
               end
               def test_update_notified_project
-                get :edit, :id => 2
+                get :edit, :params => {:id => 2}
                 assert_response :success
                 assert_template 'edit'
                 u = User.find(2)
                 assert_equal [1, 2, 5], u.projects.collect{|p| p.id}.sort
                 assert_equal [1, 2, 5], u.notified_projects_ids.sort
                 assert_select 'input[name=?][value=?]', 'user[notified_project_ids][]', '1'
                 assert_equal 'all', u.mail_notification
-                put :update, :id => 2,
+                put :update, :params => {
+                  :id => 2,
                   :user => {
                     :mail_notification => 'selected',
                     :notified_project_ids => [1, 2]
                   }
+                }
                 u = User.find(2)
                 assert_equal 'selected', u.mail_notification
                 assert_equal [1, 2], u.notified_projects_ids.sort
               end
               def test_update_status_should_not_update_attributes
                 user = User.find(2)
                 user.pref[:no_self_notified] = '1'
                 user.pref.save
-                put :update, :id => 2, :user => {:status => 3}
+                put :update, :params => {
+                  :id => 2,
+                  :user => {:status => 3}
+                }
                 assert_response 302
                 user = User.find(2)
                 assert_equal 3, user.status
                 assert_equal '1', user.pref[:no_self_notified]
               end
               def test_update_assign_admin_should_send_security_notification
                 ActionMailer::Base.deliveries.clear
-                put :update, :id => 2, :user => {
+                put :update, :params => {
-                  :admin => 1
+                  :id => 2,
+                  :user => {:admin => 1}
                 }
                 assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                 assert_mail_body_match I18n.t(:mail_body_security_notification_add, field: I18n.t(:field_admin), value: User.find(2).login), mail
                 # All admins should receive this
                 User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                   assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                 end
               end
               def test_update_unassign_admin_should_send_security_notification
                 user = User.find(2)
                 user.admin = true
                 user.save!
                 ActionMailer::Base.deliveries.clear
-                put :update, :id => user.id, :user => {
+                put :update, :params => {
-                  :admin => 0
+                  :id => user.id,
+                  :user => {:admin => 0}
                 }
                 assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                 assert_mail_body_match I18n.t(:mail_body_security_notification_remove, field: I18n.t(:field_admin), value: user.login), mail
                 # All admins should receive this
                 User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                   assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                 end
               end
               def test_update_lock_admin_should_send_security_notification
                 user = User.find(2)
                 user.admin = true
                 user.save!
                 ActionMailer::Base.deliveries.clear
-                put :update, :id => 2, :user => {
+                put :update, :params => {
-                  :status => Principal::STATUS_LOCKED
+                  :id => 2,
+                  :user => {:status => Principal::STATUS_LOCKED}
                 }
                 assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                 assert_mail_body_match I18n.t(:mail_body_security_notification_remove, field: I18n.t(:field_admin), value: User.find(2).login), mail
                 # All admins should receive this
                 User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                   assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                 end
                 # if user is already locked, destroying should not send a second mail
                 # (for active admins see furtherbelow)
                 ActionMailer::Base.deliveries.clear
-                delete :destroy, :id => 1
+                delete :destroy, :params => {:id => 1}
                 assert_nil ActionMailer::Base.deliveries.last
               end
               def test_update_unlock_admin_should_send_security_notification
                 user = User.find(5) # already locked
                 user.admin = true
                 user.save!
                 ActionMailer::Base.deliveries.clear
-                put :update, :id => user.id, :user => {
+                put :update, :params => {
-                  :status => Principal::STATUS_ACTIVE
+                  :id => user.id,
+                  :user => {:status => Principal::STATUS_ACTIVE}
                 }
                 assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                 assert_mail_body_match I18n.t(:mail_body_security_notification_add, field: I18n.t(:field_admin), value: user.login), mail
                 # All admins should receive this
                 User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                   assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                 end
               end
               def test_update_admin_unrelated_property_should_not_send_security_notification
                 ActionMailer::Base.deliveries.clear
-                put :update, :id => 1, :user => {
+                put :update, :params => {
-                  :firstname => 'Jimmy'
+                  :id => 1,
+                  :user => {:firstname => 'Jimmy'}
                 }
                 assert_nil ActionMailer::Base.deliveries.last
               end
               def test_destroy
                 assert_difference 'User.count', -1 do
-                  delete :destroy, :id => 2
+                  delete :destroy, :params => {:id => 2}
                 end
                 assert_redirected_to '/users'
                 assert_nil User.find_by_id(2)
               end
               def test_destroy_should_be_denied_for_non_admin_users
                 @request.session[:user_id] = 3
                 assert_no_difference 'User.count' do
-                  get :destroy, :id => 2
+                  get :destroy, :params => {:id => 2}
                 end
                 assert_response 403
               end
               def test_destroy_should_redirect_to_back_url_param
                 assert_difference 'User.count', -1 do
-                  delete :destroy, :id => 2, :back_url => '/users?name=foo'
+                  delete :destroy, :params => {:id => 2, :back_url => '/users?name=foo'}
                 end
                 assert_redirected_to '/users?name=foo'
               end
               def test_destroy_active_admin_should_send_security_notification
                 user = User.find(2)
                 user.admin = true
                 user.save!
                 ActionMailer::Base.deliveries.clear
-                delete :destroy, :id => user.id
+                delete :destroy, :params => {:id => user.id}
                 assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                 assert_mail_body_match I18n.t(:mail_body_security_notification_remove, field: I18n.t(:field_admin), value: user.login), mail
                 # All admins should receive this
                 User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                   assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                 end
               end
             end

test/test_helper.rb +8 0

             # 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={})
+                  if parameters.key?(:params)
+                    raise ArgumentError if options.present?
+                    super method, path, parameters[:params], parameters.except(:params)
+                  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