jro_apps/redmine Commit - r15345:e1da6de36f0d

Removes calls to #assert_template and #assigns in integration tests....

Jean-Philippe Lang -

r15345:e1da6de36f0d

parent child

Context file:

r15345:e1da6de36f0d

Collapse all files

test/integration/account_test.rb 0 -7

             # 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 AccountTest < Redmine::IntegrationTest
               fixtures :users, :email_addresses, :roles
               def test_login
                 get "/my/page"
                 assert_redirected_to "/login?back_url=http%3A%2F%2Fwww.example.com%2Fmy%2Fpage"
                 log_user('jsmith', 'jsmith')
                 get "/my/account"
                 assert_response :success
-                assert_template "my/account"
               end
               def test_login_should_set_session_token
                 assert_difference 'Token.count' do
                   log_user('jsmith', 'jsmith')
                   assert_equal 2, session[:user_id]
                   assert_not_nil session[:tk]
                 end
               end
               def test_autologin
                 user = User.find(1)
                 Token.delete_all
                 with_settings :autologin => '7' do
                   assert_difference 'Token.count', 2 do
                     # User logs in with 'autologin' checked
                     post '/login', :username => user.login, :password => 'admin', :autologin => 1
                     assert_redirected_to '/my/page'
                   end
                   token = Token.where(:action => 'autologin').order(:id => :desc).first
                   assert_not_nil token
                   assert_equal user, token.user
                   assert_equal 'autologin', token.action
                   assert_equal user.id, session[:user_id]
                   assert_equal token.value, cookies['autologin']
                   # Session is cleared
                   reset!
                   User.current = nil
                   # Clears user's last login timestamp
                   user.update_attribute :last_login_on, nil
                   assert_nil user.reload.last_login_on
                   # User comes back with user's autologin cookie
                   cookies[:autologin] = token.value
                   get '/my/page'
                   assert_response :success
-                  assert_template 'my/page'
                   assert_equal user.id, session[:user_id]
                   assert_not_nil user.reload.last_login_on
                 end
               end
               def test_autologin_should_use_autologin_cookie_name
                 Token.delete_all
                 Redmine::Configuration.stubs(:[]).with('autologin_cookie_name').returns('custom_autologin')
                 Redmine::Configuration.stubs(:[]).with('autologin_cookie_path').returns('/')
                 Redmine::Configuration.stubs(:[]).with('autologin_cookie_secure').returns(false)
                 Redmine::Configuration.stubs(:[]).with('sudo_mode_timeout').returns(15)
                 with_settings :autologin => '7' do
                   assert_difference 'Token.count', 2 do
                     post '/login', :username => 'admin', :password => 'admin', :autologin => 1
                     assert_response 302
                   end
                   assert cookies['custom_autologin'].present?
                   token = cookies['custom_autologin']
                   # Session is cleared
                   reset!
                   cookies['custom_autologin'] = token
                   get '/my/page'
                   assert_response :success
                   assert_difference 'Token.count', -2 do
                     post '/logout'
                   end
                   assert cookies['custom_autologin'].blank?
                 end
               end
               def test_lost_password
                 Token.delete_all
                 get "/account/lost_password"
                 assert_response :success
-                assert_template "account/lost_password"
                 assert_select 'input[name=mail]'
                 post "/account/lost_password", :mail => 'jSmith@somenet.foo'
                 assert_redirected_to "/login"
                 token = Token.first
                 assert_equal 'recovery', token.action
                 assert_equal 'jsmith@somenet.foo', token.user.mail
                 assert !token.expired?
                 get "/account/lost_password", :token => token.value
                 assert_response :success
-                assert_template "account/password_recovery"
                 assert_select 'input[type=hidden][name=token][value=?]', token.value
                 assert_select 'input[name=new_password]'
                 assert_select 'input[name=new_password_confirmation]'
                 post "/account/lost_password",
                      :token => token.value, :new_password => 'newpass123',
                      :new_password_confirmation => 'newpass123'
                 assert_redirected_to "/login"
                 assert_equal 'Password was successfully updated.', flash[:notice]
                 log_user('jsmith', 'newpass123')
                 assert_equal false, Token.exists?(token.id), "Password recovery token was not deleted"
               end
               def test_user_with_must_change_passwd_should_be_forced_to_change_its_password
                 User.find_by_login('jsmith').update_attribute :must_change_passwd, true
                 post '/login', :username => 'jsmith', :password => 'jsmith'
                 assert_redirected_to '/my/page'
                 follow_redirect!
                 assert_redirected_to '/my/password'
                 get '/issues'
                 assert_redirected_to '/my/password'
               end
               def test_user_with_must_change_passwd_should_be_able_to_change_its_password
                 User.find_by_login('jsmith').update_attribute :must_change_passwd, true
                 post '/login', :username => 'jsmith', :password => 'jsmith'
                 assert_redirected_to '/my/page'
                 follow_redirect!
                 assert_redirected_to '/my/password'
                 follow_redirect!
                 assert_response :success
                 post '/my/password', :password => 'jsmith', :new_password => 'newpassword', :new_password_confirmation => 'newpassword'
                 assert_redirected_to '/my/account'
                 follow_redirect!
                 assert_response :success
                 assert_equal false, User.find_by_login('jsmith').must_change_passwd?
               end
               def test_user_with_expired_password_should_be_forced_to_change_its_password
                 User.find_by_login('jsmith').update_attribute :passwd_changed_on, 14.days.ago
                 with_settings :password_max_age => 7 do
                   post '/login', :username => 'jsmith', :password => 'jsmith'
                   assert_redirected_to '/my/page'
                   follow_redirect!
                   assert_redirected_to '/my/password'
                   get '/issues'
                   assert_redirected_to '/my/password'
                 end
               end
               def test_user_with_expired_password_should_be_able_to_change_its_password
                 User.find_by_login('jsmith').update_attribute :passwd_changed_on, 14.days.ago
                 with_settings :password_max_age => 7 do
                   post '/login', :username => 'jsmith', :password => 'jsmith'
                   assert_redirected_to '/my/page'
                   follow_redirect!
                   assert_redirected_to '/my/password'
                   follow_redirect!
                   assert_response :success
                   post '/my/password', :password => 'jsmith', :new_password => 'newpassword', :new_password_confirmation => 'newpassword'
                   assert_redirected_to '/my/account'
                   follow_redirect!
                   assert_response :success
                   assert_equal false, User.find_by_login('jsmith').must_change_passwd?
                 end
               end
               def test_register_with_automatic_activation
                 Setting.self_registration = '3'
                 get '/account/register'
                 assert_response :success
-                assert_template 'account/register'
                 post '/account/register',
                      :user => {:login => "newuser", :language => "en",
                                :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar",
                                :password => "newpass123", :password_confirmation => "newpass123"}
                 assert_redirected_to '/my/account'
                 follow_redirect!
                 assert_response :success
-                assert_template 'my/account'
                 user = User.find_by_login('newuser')
                 assert_not_nil user
                 assert user.active?
                 assert_not_nil user.last_login_on
               end
               def test_register_with_manual_activation
                 Setting.self_registration = '2'
                 post '/account/register',
                      :user => {:login => "newuser", :language => "en",
                                :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar",
                                :password => "newpass123", :password_confirmation => "newpass123"}
                 assert_redirected_to '/login'
                 assert !User.find_by_login('newuser').active?
               end
               def test_register_with_email_activation
                 Setting.self_registration = '1'
                 Token.delete_all
                 post '/account/register',
                      :user => {:login => "newuser", :language => "en",
                                :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar",
                                :password => "newpass123", :password_confirmation => "newpass123"}
                 assert_redirected_to '/login'
                 assert !User.find_by_login('newuser').active?
                 token = Token.first
                 assert_equal 'register', token.action
                 assert_equal 'newuser@foo.bar', token.user.mail
                 assert !token.expired?
                 get '/account/activate', :token => token.value
                 assert_redirected_to '/login'
                 log_user('newuser', 'newpass123')
               end
               def test_onthefly_registration
                 # disable registration
                 Setting.self_registration = '0'
                 AuthSource.expects(:authenticate).returns(
                   {:login => 'foo', :firstname => 'Foo', :lastname => 'Smith',
                    :mail => 'foo@bar.com', :auth_source_id => 66})
                 post '/login', :username => 'foo', :password => 'bar'
                 assert_redirected_to '/my/page'
                 user = User.find_by_login('foo')
                 assert user.is_a?(User)
                 assert_equal 66, user.auth_source_id
                 assert user.hashed_password.blank?
               end
               def test_onthefly_registration_with_invalid_attributes
                 # disable registration
                 Setting.self_registration = '0'
                 AuthSource.expects(:authenticate).returns(
                   {:login => 'foo', :lastname => 'Smith', :auth_source_id => 66})
                 post '/login', :username => 'foo', :password => 'bar'
                 assert_response :success
-                assert_template 'account/register'
                 assert_select 'input[name=?][value=""]', 'user[firstname]'
                 assert_select 'input[name=?][value=Smith]', 'user[lastname]'
                 assert_select 'input[name=?]', 'user[login]', 0
                 assert_select 'input[name=?]', 'user[password]', 0
                 post '/account/register',
                      :user => {:firstname => 'Foo', :lastname => 'Smith', :mail => 'foo@bar.com'}
                 assert_redirected_to '/my/account'
                 user = User.find_by_login('foo')
                 assert user.is_a?(User)
                 assert_equal 66, user.auth_source_id
                 assert user.hashed_password.blank?
               end
               def test_registered_user_should_be_able_to_get_a_new_activation_email
                 Token.delete_all
                 with_settings :self_registration => '1', :default_language => 'en' do
                   # register a new account
                   assert_difference 'User.count' do
                     assert_difference 'Token.count' do
                       post '/account/register',
                          :user => {:login => "newuser", :language => "en",
                                    :firstname => "New", :lastname => "User", :mail => "newuser@foo.bar",
                                    :password => "newpass123", :password_confirmation => "newpass123"}
                     end
                   end
                   user = User.order('id desc').first
                   assert_equal User::STATUS_REGISTERED, user.status
                   reset!
                   # try to use "lost password"
                   assert_no_difference 'ActionMailer::Base.deliveries.size' do
                     post '/account/lost_password', :mail => 'newuser@foo.bar'
                   end
                   assert_redirected_to '/account/lost_password'
                   follow_redirect!
                   assert_response :success
                   assert_select 'div.flash', :text => /new activation email/
                   assert_select 'div.flash a[href="/account/activation_email"]'
                   # request a new action activation email
                   assert_difference 'ActionMailer::Base.deliveries.size' do
                     get '/account/activation_email'
                   end
                   assert_redirected_to '/login'
                   token = Token.order('id desc').first
                   activation_path = "/account/activate?token=#{token.value}"
                   assert_include activation_path, mail_body(ActionMailer::Base.deliveries.last)
                   # activate the account
                   get activation_path
                   assert_redirected_to '/login'
                   post '/login', :username => 'newuser', :password => 'newpass123'
                   assert_redirected_to '/my/page'
                 end
               end
             end

test/integration/admin_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 AdminTest < Redmine::IntegrationTest
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules
               def test_add_user
                 log_user("admin", "admin")
                 get "/users/new"
                 assert_response :success
-                assert_template "users/new"
                 post "/users",
                      :user => { :login => "psmith", :firstname => "Paul",
                                 :lastname => "Smith", :mail => "psmith@somenet.foo",
                                 :language => "en", :password => "psmith09",
                                 :password_confirmation => "psmith09" }
                 user = User.find_by_login("psmith")
                 assert_kind_of User, user
                 assert_redirected_to "/users/#{ user.id }/edit"
                 logged_user = User.try_to_login("psmith", "psmith09")
                 assert_kind_of User, logged_user
                 assert_equal "Paul", logged_user.firstname
                 put "/users/#{user.id}", :id => user.id, :user => { :status => User::STATUS_LOCKED }
                 assert_redirected_to "/users/#{ user.id }/edit"
                 locked_user = User.try_to_login("psmith", "psmith09")
                 assert_equal nil, locked_user
               end
               test "Add a user as an anonymous user should fail" do
                 post '/users',
                      :user => { :login => 'psmith', :firstname => 'Paul'},
                      :password => "psmith09", :password_confirmation => "psmith09"
                 assert_response :redirect
                 assert_redirected_to "/login?back_url=http%3A%2F%2Fwww.example.com%2Fusers"
               end
             end

test/integration/api_test/authentication_test.rb +2 -2

             # 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 Redmine::ApiTest::AuthenticationTest < Redmine::ApiTest::Base
               fixtures :users
               def test_api_should_deny_without_credentials
                 get '/users/current.xml', {}
                 assert_response 401
                 assert_equal User.anonymous, User.current
                 assert response.headers.has_key?('WWW-Authenticate')
               end
               def test_api_should_accept_http_basic_auth_using_username_and_password
                 user = User.generate! do |user|
                   user.password = 'my_password'
                 end
                 get '/users/current.xml', {}, credentials(user.login, 'my_password')
                 assert_response 200
                 assert_equal user, User.current
               end
               def test_api_should_deny_http_basic_auth_using_username_and_wrong_password
                 user = User.generate! do |user|
                   user.password = 'my_password'
                 end
                 get '/users/current.xml', {}, credentials(user.login, 'wrong_password')
                 assert_response 401
                 assert_equal User.anonymous, User.current
               end
               def test_api_should_accept_http_basic_auth_using_api_key
                 user = User.generate!
                 token = Token.create!(:user => user, :action => 'api')
                 get '/users/current.xml', {}, credentials(token.value, 'X')
                 assert_response 200
                 assert_equal user, User.current
               end
               def test_api_should_deny_http_basic_auth_using_wrong_api_key
                 user = User.generate!
                 token = Token.create!(:user => user, :action => 'feeds') # not the API key
                 get '/users/current.xml', {}, credentials(token.value, 'X')
                 assert_response 401
                 assert_equal User.anonymous, User.current
               end
               def test_api_should_accept_auth_using_api_key_as_parameter
                 user = User.generate!
                 token = Token.create!(:user => user, :action => 'api')
                 get "/users/current.xml?key=#{token.value}", {}
                 assert_response 200
                 assert_equal user, User.current
               end
               def test_api_should_deny_auth_using_wrong_api_key_as_parameter
                 user = User.generate!
                 token = Token.create!(:user => user, :action => 'feeds') # not the API key
                 get "/users/current.xml?key=#{token.value}", {}
                 assert_response 401
                 assert_equal User.anonymous, User.current
               end
               def test_api_should_accept_auth_using_api_key_as_request_header
                 user = User.generate!
                 token = Token.create!(:user => user, :action => 'api')
                 get "/users/current.xml", {}, {'X-Redmine-API-Key' => token.value.to_s}
                 assert_response 200
                 assert_equal user, User.current
               end
               def test_api_should_deny_auth_using_wrong_api_key_as_request_header
                 user = User.generate!
                 token = Token.create!(:user => user, :action => 'feeds') # not the API key
                 get "/users/current.xml", {}, {'X-Redmine-API-Key' => token.value.to_s}
                 assert_response 401
                 assert_equal User.anonymous, User.current
               end
               def test_api_should_trigger_basic_http_auth_with_basic_authorization_header
                 ApplicationController.any_instance.expects(:authenticate_with_http_basic).once
                 get '/users/current.xml', {}, credentials('jsmith')
                 assert_response 401
               end
               def test_api_should_not_trigger_basic_http_auth_with_non_basic_authorization_header
                 ApplicationController.any_instance.expects(:authenticate_with_http_basic).never
                 get '/users/current.xml', {}, 'HTTP_AUTHORIZATION' => 'Digest foo bar'
                 assert_response 401
               end
               def test_invalid_utf8_credentials_should_not_trigger_an_error
                 invalid_utf8 = "\x82".force_encoding('UTF-8')
                 assert !invalid_utf8.valid_encoding?
                 assert_nothing_raised do
                   get '/users/current.xml', {}, credentials(invalid_utf8, "foo")
                 end
               end
               def test_api_request_should_not_use_user_session
                 log_user('jsmith', 'jsmith')
                 get '/users/current'
                 assert_response :success
                 get '/users/current.json'
                 assert_response 401
               end
               def test_api_should_accept_switch_user_header_for_admin_user
                 user = User.find(1)
                 su = User.find(4)
                 get '/users/current', {}, {'X-Redmine-API-Key' => user.api_key, 'X-Redmine-Switch-User' => su.login}
                 assert_response :success
-                assert_equal su, assigns(:user)
+                assert_select 'h2', :text => su.name
                 assert_equal su, User.current
               end
               def test_api_should_respond_with_412_when_trying_to_switch_to_a_invalid_user
                 get '/users/current', {}, {'X-Redmine-API-Key' => User.find(1).api_key, 'X-Redmine-Switch-User' => 'foobar'}
                 assert_response 412
               end
               def test_api_should_respond_with_412_when_trying_to_switch_to_a_locked_user
                 user = User.find(5)
                 assert user.locked?
                 get '/users/current', {}, {'X-Redmine-API-Key' => User.find(1).api_key, 'X-Redmine-Switch-User' => user.login}
                 assert_response 412
               end
               def test_api_should_not_accept_switch_user_header_for_non_admin_user
                 user = User.find(2)
                 su = User.find(4)
                 get '/users/current', {}, {'X-Redmine-API-Key' => user.api_key, 'X-Redmine-Switch-User' => su.login}
                 assert_response :success
-                assert_equal user, assigns(:user)
+                assert_select 'h2', :text => user.name
                 assert_equal user, User.current
               end
             end

test/integration/api_test/issues_test.rb +2 -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 Redmine::ApiTest::IssuesTest < Redmine::ApiTest::Base
               fixtures :projects,
                 :users,
                 :roles,
                 :members,
                 :member_roles,
                 :issues,
                 :issue_statuses,
                 :issue_relations,
                 :versions,
                 :trackers,
                 :projects_trackers,
                 :issue_categories,
                 :enabled_modules,
                 :enumerations,
                 :attachments,
                 :workflows,
                 :custom_fields,
                 :custom_values,
                 :custom_fields_projects,
                 :custom_fields_trackers,
                 :time_entries,
                 :journals,
                 :journal_details,
                 :queries,
                 :attachments
               test "GET /issues.xml should contain metadata" do
                 get '/issues.xml'
-                assert_select 'issues[type=array][total_count=?][limit="25"][offset="0"]',
+                assert_select 'issues[type=array][total_count][limit="25"][offset="0"]'
-                  assigns(:issue_count).to_s
               end
               test "GET /issues.xml with nometa param should not contain metadata" do
                 get '/issues.xml?nometa=1'
                 assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'
               end
               test "GET /issues.xml with nometa header should not contain metadata" do
                 get '/issues.xml', {}, {'X-Redmine-Nometa' => '1'}
                 assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'
               end
               test "GET /issues.xml with offset and limit" do
                 get '/issues.xml?offset=2&limit=3'
+                assert_select 'issues[type=array][total_count][limit="3"][offset="2"]'
-                assert_equal 3, assigns(:limit)
-                assert_equal 2, assigns(:offset)
                 assert_select 'issues issue', 3
               end
               test "GET /issues.xml with relations" do
                 get '/issues.xml?include=relations'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                 assert_select 'issue id', :text => '3' do
                   assert_select '~ relations relation', 1
                   assert_select '~ relations relation[id="2"][issue_id="2"][issue_to_id="3"][relation_type=relates]'
                 end
                 assert_select 'issue id', :text => '1' do
                   assert_select '~ relations'
                   assert_select '~ relations relation', 0
                 end
               end
               test "GET /issues.xml with invalid query params" do
                 get '/issues.xml', {:f => ['start_date'], :op => {:start_date => '='}}
                 assert_response :unprocessable_entity
                 assert_equal 'application/xml', @response.content_type
                 assert_select 'errors error', :text => "Start date cannot be blank"
               end
               test "GET /issues.xml with custom field filter" do
                 get '/issues.xml',
                   {:set_filter => 1, :f => ['cf_1'], :op => {:cf_1 => '='}, :v => {:cf_1 => ['MySQL']}}
                 expected_ids = Issue.visible.
                     joins(:custom_values).
                     where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
                 assert expected_ids.any?
                 assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                    ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                 end
               end
               test "GET /issues.xml with custom field filter (shorthand method)" do
                 get '/issues.xml', {:cf_1 => 'MySQL'}
                 expected_ids = Issue.visible.
                     joins(:custom_values).
                     where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
                 assert expected_ids.any?
                 assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                   ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                 end
               end
               def test_index_should_include_issue_attributes
                 get '/issues.xml'
                 assert_select 'issues>issue>is_private', :text => 'false'
               end
               def test_index_should_allow_timestamp_filtering
                 Issue.delete_all
                 Issue.generate!(:subject => '1').update_column(:updated_on, Time.parse("2014-01-02T10:25:00Z"))
                 Issue.generate!(:subject => '2').update_column(:updated_on, Time.parse("2014-01-02T12:13:00Z"))
                 get '/issues.xml',
                   {:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '<='},
                    :v => {:updated_on => ['2014-01-02T12:00:00Z']}}
                 assert_select 'issues>issue', :count => 1
                 assert_select 'issues>issue>subject', :text => '1'
                 get '/issues.xml',
                   {:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '>='},
                    :v => {:updated_on => ['2014-01-02T12:00:00Z']}}
                 assert_select 'issues>issue', :count => 1
                 assert_select 'issues>issue>subject', :text => '2'
                 get '/issues.xml',
                   {:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '>='},
                    :v => {:updated_on => ['2014-01-02T08:00:00Z']}}
                 assert_select 'issues>issue', :count => 2
               end
               test "GET /issues.xml with filter" do
                 get '/issues.xml?status_id=5'
                 expected_ids = Issue.visible.where(:status_id => 5).map(&:id)
                 assert expected_ids.any?
                 assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                    ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                 end
               end
               test "GET /issues.json with filter" do
                 get '/issues.json?status_id=5'
                 json = ActiveSupport::JSON.decode(response.body)
                 status_ids_used = json['issues'].collect {|j| j['status']['id'] }
                 assert_equal 3, status_ids_used.length
                 assert status_ids_used.all? {|id| id == 5 }
               end
               test "GET /issues/:id.xml with journals" do
                 Journal.find(2).update_attribute(:private_notes, true)
                 get '/issues/1.xml?include=journals', {}, credentials('jsmith')
                 assert_select 'issue journals[type=array]' do
                   assert_select 'journal[id="1"]' do
                     assert_select 'private_notes', :text => 'false'
                     assert_select 'details[type=array]' do
                       assert_select 'detail[name=status_id]' do
                         assert_select 'old_value', :text => '1'
                         assert_select 'new_value', :text => '2'
                       end
                     end
                   end
                   assert_select 'journal[id="2"]' do
                     assert_select 'private_notes', :text => 'true'
                     assert_select 'details[type=array]'
                   end
                 end
               end
               test "GET /issues/:id.xml with journals should format timestamps in ISO 8601" do
                 get '/issues/1.xml?include=journals'
                 iso_date = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/
                 assert_select 'issue>created_on', :text => iso_date
                 assert_select 'issue>updated_on', :text => iso_date
                 assert_select 'issue journal>created_on', :text => iso_date
               end
               test "GET /issues/:id.xml with custom fields" do
                 get '/issues/3.xml'
                 assert_select 'issue custom_fields[type=array]' do
                   assert_select 'custom_field[id="1"]' do
                     assert_select 'value', :text => 'MySQL'
                   end
                 end
                 assert_nothing_raised do
                   Hash.from_xml(response.body).to_xml
                 end
               end
               test "GET /issues/:id.xml with multi custom fields" do
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 issue = Issue.find(3)
                 issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                 issue.save!
                 get '/issues/3.xml'
                 assert_response :success
                 assert_select 'issue custom_fields[type=array]' do
                   assert_select 'custom_field[id="1"]' do
                     assert_select 'value[type=array] value', 2
                   end
                 end
                 xml = Hash.from_xml(response.body)
                 custom_fields = xml['issue']['custom_fields']
                 assert_kind_of Array, custom_fields
                 field = custom_fields.detect {|f| f['id'] == '1'}
                 assert_kind_of Hash, field
                 assert_equal ['MySQL', 'Oracle'], field['value'].sort
               end
               test "GET /issues/:id.json with multi custom fields" do
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 issue = Issue.find(3)
                 issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                 issue.save!
                 get '/issues/3.json'
                 assert_response :success
                 json = ActiveSupport::JSON.decode(response.body)
                 custom_fields = json['issue']['custom_fields']
                 assert_kind_of Array, custom_fields
                 field = custom_fields.detect {|f| f['id'] == 1}
                 assert_kind_of Hash, field
                 assert_equal ['MySQL', 'Oracle'], field['value'].sort
               end
               test "GET /issues/:id.xml with empty value for multi custom field" do
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 issue = Issue.find(3)
                 issue.custom_field_values = {1 => ['']}
                 issue.save!
                 get '/issues/3.xml'
                 assert_select 'issue custom_fields[type=array]' do
                   assert_select 'custom_field[id="1"]' do
                     assert_select 'value[type=array]:empty'
                   end
                 end
                 xml = Hash.from_xml(response.body)
                 custom_fields = xml['issue']['custom_fields']
                 assert_kind_of Array, custom_fields
                 field = custom_fields.detect {|f| f['id'] == '1'}
                 assert_kind_of Hash, field
                 assert_equal [], field['value']
               end
               test "GET /issues/:id.json with empty value for multi custom field" do
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 issue = Issue.find(3)
                 issue.custom_field_values = {1 => ['']}
                 issue.save!
                 get '/issues/3.json'
                 assert_response :success
                 json = ActiveSupport::JSON.decode(response.body)
                 custom_fields = json['issue']['custom_fields']
                 assert_kind_of Array, custom_fields
                 field = custom_fields.detect {|f| f['id'] == 1}
                 assert_kind_of Hash, field
                 assert_equal [], field['value'].sort
               end
               test "GET /issues/:id.xml with attachments" do
                 get '/issues/3.xml?include=attachments'
                 assert_select 'issue attachments[type=array]' do
                   assert_select 'attachment', 4
                   assert_select 'attachment id', :text => '1' do
                     assert_select '~ filename', :text => 'error281.txt'
                     assert_select '~ content_url', :text => 'http://www.example.com/attachments/download/1/error281.txt'
                   end
                 end
               end
               test "GET /issues/:id.xml with subtasks" do
                 issue = Issue.generate_with_descendants!(:project_id => 1)
                 get "/issues/#{issue.id}.xml?include=children"
                 assert_select 'issue id', :text => issue.id.to_s do
                   assert_select '~ children[type=array] > issue', 2
                   assert_select '~ children[type=array] > issue > children', 1
                 end
               end
               test "GET /issues/:id.json with subtasks" do
                 issue = Issue.generate_with_descendants!(:project_id => 1)
                 get "/issues/#{issue.id}.json?include=children"
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_equal 2, json['issue']['children'].size
                 assert_equal 1, json['issue']['children'].select {|child| child.key?('children')}.size
               end
               def test_show_should_include_issue_attributes
                 get '/issues/1.xml'
                 assert_select 'issue>is_private', :text => 'false'
               end
               test "GET /issues/:id.xml?include=watchers should include watchers" do
                 Watcher.create!(:user_id => 3, :watchable => Issue.find(1))
                 get '/issues/1.xml?include=watchers', {}, credentials('jsmith')
                 assert_response :ok
                 assert_equal 'application/xml', response.content_type
                 assert_select 'issue' do
                   assert_select 'watchers', Issue.find(1).watchers.count
                   assert_select 'watchers' do
                     assert_select 'user[id="3"]'
                   end
                 end
               end
               test "GET /issues/:id.xml should not disclose associated changesets from projects the user has no access to" do
                 project = Project.generate!(:is_public => false)
                 repository = Repository::Subversion.create!(:project => project, :url => "svn://localhost")
                 Issue.find(1).changesets << Changeset.generate!(:repository => repository)
                 assert Issue.find(1).changesets.any?
                 get '/issues/1.xml?include=changesets', {}, credentials('jsmith')
                 # the user jsmith has no permission to view the associated changeset
                 assert_select 'issue changesets[type=array]' do
                   assert_select 'changeset', 0
                 end
               end
               test "GET /issues/:id.xml should contains total_estimated_hours and total_spent_hours" do
                 parent = Issue.find(3)
                 child = Issue.generate!(:parent_issue_id => parent.id, :estimated_hours => 3.0)
                 TimeEntry.create!(:project => child.project, :issue => child, :user => child.author, :spent_on => child.author.today,
                                   :hours => '2.5', :comments => '', :activity_id => TimeEntryActivity.first.id)
                 get '/issues/3.xml'
                 assert_equal 'application/xml', response.content_type
                 assert_select 'issue' do
                   assert_select 'estimated_hours',       parent.estimated_hours.to_s
                   assert_select 'total_estimated_hours', (parent.estimated_hours.to_f + 3.0).to_s
                   assert_select 'spent_hours',           parent.spent_hours.to_s
                   assert_select 'total_spent_hours',     (parent.spent_hours.to_f + 2.5).to_s
                 end
               end
               test "GET /issues/:id.xml should contains total_estimated_hours, and should not contains spent_hours and total_spent_hours when permission does not exists" do
                 parent = Issue.find(3)
                 child = Issue.generate!(:parent_issue_id => parent.id, :estimated_hours => 3.0)
                 # remove permission!
                 Role.anonymous.remove_permission! :view_time_entries
                 #Role.all.each { |role| role.remove_permission! :view_time_entries }
                 get '/issues/3.xml'
                 assert_equal 'application/xml', response.content_type
                 assert_select 'issue' do
                   assert_select 'estimated_hours',       parent.estimated_hours.to_s
                   assert_select 'total_estimated_hours', (parent.estimated_hours.to_f + 3.0).to_s
                   assert_select 'spent_hours',           false
                   assert_select 'total_spent_hours',     false
                 end
               end
               test "GET /issues/:id.json should contains total_estimated_hours and total_spent_hours" do
                 parent = Issue.find(3)
                 child = Issue.generate!(:parent_issue_id => parent.id, :estimated_hours => 3.0)
                 TimeEntry.create!(:project => child.project, :issue => child, :user => child.author, :spent_on => child.author.today,
                                   :hours => '2.5', :comments => '', :activity_id => TimeEntryActivity.first.id)
                 get '/issues/3.json'
                 assert_equal 'application/json', response.content_type
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_equal parent.estimated_hours, json['issue']['estimated_hours']
                 assert_equal (parent.estimated_hours.to_f + 3.0), json['issue']['total_estimated_hours']
                 assert_equal parent.spent_hours, json['issue']['spent_hours']
                 assert_equal (parent.spent_hours.to_f + 2.5), json['issue']['total_spent_hours']
               end
               test "GET /issues/:id.json should contains total_estimated_hours, and should not contains spent_hours and total_spent_hours when permission does not exists" do
                 parent = Issue.find(3)
                 child = Issue.generate!(:parent_issue_id => parent.id, :estimated_hours => 3.0)
                 # remove permission!
                 Role.anonymous.remove_permission! :view_time_entries
                 #Role.all.each { |role| role.remove_permission! :view_time_entries }
                 get '/issues/3.json'
                 assert_equal 'application/json', response.content_type
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_equal parent.estimated_hours, json['issue']['estimated_hours']
                 assert_equal (parent.estimated_hours.to_f + 3.0), json['issue']['total_estimated_hours']
                 assert_equal nil, json['issue']['spent_hours']
                 assert_equal nil, json['issue']['total_spent_hours']
               end
               test "POST /issues.xml should create an issue with the attributes" do
             payload = <<-XML
             <?xml version="1.0" encoding="UTF-8" ?>
             <issue>
               <project_id>1</project_id>
               <tracker_id>2</tracker_id>
               <status_id>3</status_id>
               <subject>API test</subject>
             </issue>
             XML
                 assert_difference('Issue.count') do
                   post '/issues.xml', payload, {"CONTENT_TYPE" => 'application/xml'}.merge(credentials('jsmith'))
                 end
                 issue = Issue.order('id DESC').first
                 assert_equal 1, issue.project_id
                 assert_equal 2, issue.tracker_id
                 assert_equal 3, issue.status_id
                 assert_equal 'API test', issue.subject
                 assert_response :created
                 assert_equal 'application/xml', @response.content_type
                 assert_select 'issue > id', :text => issue.id.to_s
               end
               test "POST /issues.xml with watcher_user_ids should create issue with watchers" do
                 assert_difference('Issue.count') do
                   post '/issues.xml',
                        {:issue => {:project_id => 1, :subject => 'Watchers',
                         :tracker_id => 2, :status_id => 3, :watcher_user_ids => [3, 1]}}, credentials('jsmith')
                   assert_response :created
                 end
                 issue = Issue.order('id desc').first
                 assert_equal 2, issue.watchers.size
                 assert_equal [1, 3], issue.watcher_user_ids.sort
               end
               test "POST /issues.xml with failure should return errors" do
                 assert_no_difference('Issue.count') do
                   post '/issues.xml', {:issue => {:project_id => 1}}, credentials('jsmith')
                 end
                 assert_select 'errors error', :text => "Subject cannot be blank"
               end
               test "POST /issues.json should create an issue with the attributes" do
             payload = <<-JSON
             {
               "issue": {
                 "project_id": "1",
                 "tracker_id": "2",
                 "status_id": "3",
                 "subject": "API test"
               }
             }
             JSON
                 assert_difference('Issue.count') do
                   post '/issues.json', payload, {"CONTENT_TYPE" => 'application/json'}.merge(credentials('jsmith'))
                 end
                 issue = Issue.order('id DESC').first
                 assert_equal 1, issue.project_id
                 assert_equal 2, issue.tracker_id
                 assert_equal 3, issue.status_id
                 assert_equal 'API test', issue.subject
               end
               test "POST /issues.json without tracker_id should accept custom fields" do
                 field = IssueCustomField.generate!(
                   :field_format => 'list',
                   :multiple => true,
                   :possible_values => ["V1", "V2", "V3"],
                   :default_value => "V2",
                   :is_for_all => true,
                   :trackers => Tracker.all.to_a
                 )
             payload = <<-JSON
             {
               "issue": {
                 "project_id": "1",
                 "subject": "Multivalued custom field",
                 "custom_field_values":{"#{field.id}":["V1","V3"]}
               }
             }
             JSON
                 assert_difference('Issue.count') do
                   post '/issues.json', payload, {"CONTENT_TYPE" => 'application/json'}.merge(credentials('jsmith'))
                 end
                 assert_response :created
                 issue = Issue.order('id DESC').first
                 assert_equal ["V1", "V3"], issue.custom_field_value(field).sort
               end
               test "POST /issues.json with omitted custom field should set default value" do
                 field = IssueCustomField.generate!(:default_value => "Default")
                 issue = new_record(Issue) do
                   post '/issues.json',
                     {:issue => {:project_id => 1, :subject => 'API', :custom_field_values => {}}},
                     credentials('jsmith')
                 end
                 assert_equal "Default", issue.custom_field_value(field)
               end
               test "POST /issues.json with custom field set to blank should not set default value" do
                 field = IssueCustomField.generate!(:default_value => "Default")
                 issue = new_record(Issue) do
                   post '/issues.json',
                     {:issue => {:project_id => 1, :subject => 'API', :custom_field_values => {field.id.to_s => ""}}},
                     credentials('jsmith')
                 end
                 assert_equal "", issue.custom_field_value(field)
               end
               test "POST /issues.json with failure should return errors" do
                 assert_no_difference('Issue.count') do
                   post '/issues.json', {:issue => {:project_id => 1}}, credentials('jsmith')
                 end
                 json = ActiveSupport::JSON.decode(response.body)
                 assert json['errors'].include?("Subject cannot be blank")
               end
               test "POST /issues.json with invalid project_id should respond with 422" do
                 post '/issues.json', {:issue => {:project_id => 999, :subject => "API"}}, credentials('jsmith')
                 assert_response 422
               end
               test "PUT /issues/:id.xml" do
                 assert_difference('Journal.count') do
                   put '/issues/6.xml',
                     {:issue => {:subject => 'API update', :notes => 'A new note'}},
                     credentials('jsmith')
                 end
                 issue = Issue.find(6)
                 assert_equal "API update", issue.subject
                 journal = Journal.last
                 assert_equal "A new note", journal.notes
               end
               test "PUT /issues/:id.xml with custom fields" do
                 put '/issues/3.xml',
                   {:issue => {:custom_fields => [
                     {'id' => '1', 'value' => 'PostgreSQL' },
                     {'id' => '2', 'value' => '150'}
                     ]}},
                   credentials('jsmith')
                 issue = Issue.find(3)
                 assert_equal '150', issue.custom_value_for(2).value
                 assert_equal 'PostgreSQL', issue.custom_value_for(1).value
               end
               test "PUT /issues/:id.xml with multi custom fields" do
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 put '/issues/3.xml',
                   {:issue => {:custom_fields => [
                     {'id' => '1', 'value' => ['MySQL', 'PostgreSQL'] },
                     {'id' => '2', 'value' => '150'}
                     ]}},
                   credentials('jsmith')
                 issue = Issue.find(3)
                 assert_equal '150', issue.custom_value_for(2).value
                 assert_equal ['MySQL', 'PostgreSQL'], issue.custom_field_value(1).sort
               end
               test "PUT /issues/:id.xml with project change" do
                 put '/issues/3.xml',
                   {:issue => {:project_id => 2, :subject => 'Project changed'}},
                   credentials('jsmith')
                 issue = Issue.find(3)
                 assert_equal 2, issue.project_id
                 assert_equal 'Project changed', issue.subject
               end
               test "PUT /issues/:id.xml with notes only" do
                 assert_difference('Journal.count') do
                   put '/issues/6.xml',
                     {:issue => {:notes => 'Notes only'}},
                     credentials('jsmith')
                 end
                 journal = Journal.last
                 assert_equal "Notes only", journal.notes
               end
               test "PUT /issues/:id.json with omitted custom field should not change blank value to default value" do
                 field = IssueCustomField.generate!(:default_value => "Default")
                 issue = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {field.id.to_s => ""})
                 assert_equal "", issue.reload.custom_field_value(field)
                 assert_difference('Journal.count') do
                   put "/issues/#{issue.id}.json",
                     {:issue => {:custom_field_values => {}, :notes => 'API'}},
                     credentials('jsmith')
                 end
                 assert_equal "", issue.reload.custom_field_value(field)
               end
               test "PUT /issues/:id.json with custom field set to blank should not change blank value to default value" do
                 field = IssueCustomField.generate!(:default_value => "Default")
                 issue = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {field.id.to_s => ""})
                 assert_equal "", issue.reload.custom_field_value(field)
                 assert_difference('Journal.count') do
                   put "/issues/#{issue.id}.json",
                     {:issue => {:custom_field_values => {field.id.to_s => ""}, :notes => 'API'}},
                     credentials('jsmith')
                 end
                 assert_equal "", issue.reload.custom_field_value(field)
               end
               test "PUT /issues/:id.json with tracker change and omitted custom field specific to that tracker should set default value" do
                 field = IssueCustomField.generate!(:default_value => "Default", :tracker_ids => [2])
                 issue = Issue.generate!(:project_id => 1, :tracker_id => 1)
                 assert_difference('Journal.count') do
                   put "/issues/#{issue.id}.json",
                     {:issue => {:tracker_id => 2, :custom_field_values => {}, :notes => 'API'}},
                     credentials('jsmith')
                 end
                 assert_equal 2, issue.reload.tracker_id
                 assert_equal "Default", issue.reload.custom_field_value(field)
               end
               test "PUT /issues/:id.json with tracker change and custom field specific to that tracker set to blank should not set default value" do
                 field = IssueCustomField.generate!(:default_value => "Default", :tracker_ids => [2])
                 issue = Issue.generate!(:project_id => 1, :tracker_id => 1)
                 assert_difference('Journal.count') do
                   put "/issues/#{issue.id}.json",
                     {:issue => {:tracker_id => 2, :custom_field_values => {field.id.to_s => ""}, :notes => 'API'}},
                     credentials('jsmith')
                 end
                 assert_equal 2, issue.reload.tracker_id
                 assert_equal "", issue.reload.custom_field_value(field)
               end
               test "PUT /issues/:id.xml with failed update" do
                 put '/issues/6.xml', {:issue => {:subject => ''}}, credentials('jsmith')
                 assert_response :unprocessable_entity
                 assert_select 'errors error', :text => "Subject cannot be blank"
               end
               test "PUT /issues/:id.json" do
                 assert_difference('Journal.count') do
                   put '/issues/6.json',
                     {:issue => {:subject => 'API update', :notes => 'A new note'}},
                     credentials('jsmith')
                   assert_response :ok
                   assert_equal '', response.body
                 end
                 issue = Issue.find(6)
                 assert_equal "API update", issue.subject
                 journal = Journal.last
                 assert_equal "A new note", journal.notes
               end
               test "PUT /issues/:id.json with failed update" do
                 put '/issues/6.json', {:issue => {:subject => ''}}, credentials('jsmith')
                 assert_response :unprocessable_entity
                 json = ActiveSupport::JSON.decode(response.body)
                 assert json['errors'].include?("Subject cannot be blank")
               end
               test "DELETE /issues/:id.xml" do
                 assert_difference('Issue.count', -1) do
                   delete '/issues/6.xml', {}, credentials('jsmith')
                   assert_response :ok
                   assert_equal '', response.body
                 end
                 assert_nil Issue.find_by_id(6)
               end
               test "DELETE /issues/:id.json" do
                 assert_difference('Issue.count', -1) do
                   delete '/issues/6.json', {}, credentials('jsmith')
                   assert_response :ok
                   assert_equal '', response.body
                 end
                 assert_nil Issue.find_by_id(6)
               end
               test "POST /issues/:id/watchers.xml should add watcher" do
                 assert_difference 'Watcher.count' do
                   post '/issues/1/watchers.xml', {:user_id => 3}, credentials('jsmith')
                   assert_response :ok
                   assert_equal '', response.body
                 end
                 watcher = Watcher.order('id desc').first
                 assert_equal Issue.find(1), watcher.watchable
                 assert_equal User.find(3), watcher.user
               end
               test "DELETE /issues/:id/watchers/:user_id.xml should remove watcher" do
                 Watcher.create!(:user_id => 3, :watchable => Issue.find(1))
                 assert_difference 'Watcher.count', -1 do
                   delete '/issues/1/watchers/3.xml', {}, credentials('jsmith')
                   assert_response :ok
                   assert_equal '', response.body
                 end
                 assert_equal false, Issue.find(1).watched_by?(User.find(3))
               end
               def test_create_issue_with_uploaded_file
                 token = xml_upload('test_create_with_upload', credentials('jsmith'))
                 attachment = Attachment.find_by_token(token)
                 # create the issue with the upload's token
                 assert_difference 'Issue.count' do
                   post '/issues.xml',
                        {:issue => {:project_id => 1, :subject => 'Uploaded file',
                                    :uploads => [{:token => token, :filename => 'test.txt',
                                                  :content_type => 'text/plain'}]}},
                        credentials('jsmith')
                   assert_response :created
                 end
                 issue = Issue.order('id DESC').first
                 assert_equal 1, issue.attachments.count
                 assert_equal attachment, issue.attachments.first
                 attachment.reload
                 assert_equal 'test.txt', attachment.filename
                 assert_equal 'text/plain', attachment.content_type
                 assert_equal 'test_create_with_upload'.size, attachment.filesize
                 assert_equal 2, attachment.author_id
                 # get the issue with its attachments
                 get "/issues/#{issue.id}.xml", :include => 'attachments'
                 assert_response :success
                 xml = Hash.from_xml(response.body)
                 attachments = xml['issue']['attachments']
                 assert_kind_of Array, attachments
                 assert_equal 1, attachments.size
                 url = attachments.first['content_url']
                 assert_not_nil url
                 # download the attachment
                 get url
                 assert_response :success
                 assert_equal 'test_create_with_upload', response.body
               end
               def test_create_issue_with_multiple_uploaded_files_as_xml
                 token1 = xml_upload('File content 1', credentials('jsmith'))
                 token2 = xml_upload('File content 2', credentials('jsmith'))
                 payload = <<-XML
             <?xml version="1.0" encoding="UTF-8" ?>
             <issue>
               <project_id>1</project_id>
               <tracker_id>1</tracker_id>
               <subject>Issue with multiple attachments</subject>
               <uploads type="array">
                 <upload>
                   <token>#{token1}</token>
                   <filename>test1.txt</filename>
                 </upload>
                 <upload>
                   <token>#{token2}</token>
                   <filename>test1.txt</filename>
                 </upload>
               </uploads>
             </issue>
             XML
                 assert_difference 'Issue.count' do
                   post '/issues.xml', payload, {"CONTENT_TYPE" => 'application/xml'}.merge(credentials('jsmith'))
                   assert_response :created
                 end
                 issue = Issue.order('id DESC').first
                 assert_equal 2, issue.attachments.count
               end
               def test_create_issue_with_multiple_uploaded_files_as_json
                 token1 = json_upload('File content 1', credentials('jsmith'))
                 token2 = json_upload('File content 2', credentials('jsmith'))
                 payload = <<-JSON
             {
               "issue": {
                 "project_id": "1",
                 "tracker_id": "1",
                 "subject": "Issue with multiple attachments",
                 "uploads": [
                   {"token": "#{token1}", "filename": "test1.txt"},
                   {"token": "#{token2}", "filename": "test2.txt"}
                 ]
               }
             }
             JSON
                 assert_difference 'Issue.count' do
                   post '/issues.json', payload, {"CONTENT_TYPE" => 'application/json'}.merge(credentials('jsmith'))
                   assert_response :created
                 end
                 issue = Issue.order('id DESC').first
                 assert_equal 2, issue.attachments.count
               end
               def test_update_issue_with_uploaded_file
                 token = xml_upload('test_upload_with_upload', credentials('jsmith'))
                 attachment = Attachment.find_by_token(token)
                 # update the issue with the upload's token
                 assert_difference 'Journal.count' do
                   put '/issues/1.xml',
                       {:issue => {:notes => 'Attachment added',
                                   :uploads => [{:token => token, :filename => 'test.txt',
                                                 :content_type => 'text/plain'}]}},
                       credentials('jsmith')
                   assert_response :ok
                   assert_equal '', @response.body
                 end
                 issue = Issue.find(1)
                 assert_include attachment, issue.attachments
               end
             end

test/integration/api_test/roles_test.rb +2 -2

             # 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 Redmine::ApiTest::RolesTest < Redmine::ApiTest::Base
               fixtures :roles
               test "GET /roles.xml should return the roles" do
                 get '/roles.xml'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
-                assert_equal 3, assigns(:roles).size
+                assert_select 'roles role', 3
                 assert_select 'roles[type=array] role id', :text => '2' do
                   assert_select '~ name', :text => 'Developer'
                 end
               end
               test "GET /roles.json should return the roles" do
                 get '/roles.json'
                 assert_response :success
                 assert_equal 'application/json', @response.content_type
-                assert_equal 3, assigns(:roles).size
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_kind_of Hash, json
                 assert_kind_of Array, json['roles']
+                assert_equal 3, json['roles'].size
                 assert_include({'id' => 2, 'name' => 'Developer'}, json['roles'])
               end
               test "GET /roles/:id.xml should return the role" do
                 get '/roles/1.xml'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
                 assert_select 'role' do
                   assert_select 'name', :text => 'Manager'
                   assert_select 'role permissions[type=array]' do
                     assert_select 'permission', Role.find(1).permissions.size
                     assert_select 'permission', :text => 'view_issues'
                   end
                 end
               end
             end

test/integration/api_test/search_test.rb +11 -11

             # 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 Redmine::ApiTest::SearchTest < Redmine::ApiTest::Base
               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
               test "GET /search.xml should return xml content" do
                 get '/search.xml'
                 assert_response :success
                 assert_equal 'application/xml', @response.content_type
               end
               test "GET /search.json should return json content" do
                 get '/search.json'
                 assert_response :success
                 assert_equal 'application/json', @response.content_type
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_kind_of Hash, json
                 assert_kind_of Array, json['results']
               end
               test "GET /search.xml without query strings should return empty results" do
                 get '/search.xml', :q => '', :all_words => ''
                 assert_response :success
-                assert_equal 0, assigns(:results).size
+                assert_select 'result', 0
               end
               test "GET /search.xml with query strings should return results" do
-                get '/search.xml', :q => 'recipe subproject commit', :all_words => ''
+                issue = Issue.generate!(:subject => 'searchapi')
+                get '/search.xml', :q => 'searchapi', :all_words => ''
                 assert_response :success
-                assert_not_empty(assigns(:results))
                 assert_select 'results[type=array]' do
-                  assert_select 'result', :count => assigns(:results).count
+                  assert_select 'result', 1
-                  assigns(:results).size.times.each do |i|
                   assert_select 'result' do
-                      assert_select 'id',          :text => assigns(:results)[i].id.to_s
+                    assert_select 'id',          :text => issue.id.to_s
-                      assert_select 'title',       :text => assigns(:results)[i].event_title
+                    assert_select 'title',       :text => "Bug ##{issue.id} (New): searchapi"
-                      assert_select 'type',        :text => assigns(:results)[i].event_type
+                    assert_select 'type',        :text => 'issue'
-                      assert_select 'url',         :text => url_for(assigns(:results)[i].event_url(:only_path => false))
+                    assert_select 'url',         :text => "http://www.example.com/issues/#{issue.id}"
-                      assert_select 'description', :text => assigns(:results)[i].event_description
+                    assert_select 'description', :text => ''
                     assert_select 'datetime'
                   end
                 end
               end
-              end
               test "GET /search.xml should paginate" do
                 issue = (0..10).map {Issue.generate! :subject => 'search_with_limited_results'}.reverse.map(&:id)
                 get '/search.json', :q => 'search_with_limited_results', :limit => 4
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_equal 11, json['total_count']
                 assert_equal 0, json['offset']
                 assert_equal 4, json['limit']
                 assert_equal issue[0..3], json['results'].map {|r| r['id']}
                 get '/search.json', :q => 'search_with_limited_results', :offset => 8, :limit => 4
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_equal 11, json['total_count']
                 assert_equal 8, json['offset']
                 assert_equal 4, json['limit']
                 assert_equal issue[8..10], json['results'].map {|r| r['id']}
               end
             end

test/integration/api_test/users_test.rb +2 -2

             # 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 Redmine::ApiTest::UsersTest < Redmine::ApiTest::Base
               fixtures :users, :email_addresses, :members, :member_roles, :roles, :projects
               test "GET /users.xml should return users" do
                 get '/users.xml', {}, credentials('admin')
                 assert_response :success
                 assert_equal 'application/xml', response.content_type
                 assert_select 'users' do
-                  assert_select 'user', assigns(:users).size
+                  assert_select 'user', User.active.count
                 end
               end
               test "GET /users.json should return users" do
                 get '/users.json', {}, credentials('admin')
                 assert_response :success
                 assert_equal 'application/json', response.content_type
                 json = ActiveSupport::JSON.decode(response.body)
                 assert json.key?('users')
-                assert_equal assigns(:users).size, json['users'].size
+                assert_equal User.active.count, json['users'].size
               end
               test "GET /users/:id.xml should return the user" do
                 get '/users/2.xml'
                 assert_response :success
                 assert_select 'user id', :text => '2'
               end
               test "GET /users/:id.json should return the user" do
                 get '/users/2.json'
                 assert_response :success
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_kind_of Hash, json
                 assert_kind_of Hash, json['user']
                 assert_equal 2, json['user']['id']
               end
               test "GET /users/:id.xml with include=memberships should include memberships" do
                 get '/users/2.xml?include=memberships'
                 assert_response :success
                 assert_select 'user memberships', 1
               end
               test "GET /users/:id.json with include=memberships should include memberships" do
                 get '/users/2.json?include=memberships'
                 assert_response :success
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_kind_of Array, json['user']['memberships']
                 assert_equal [{
                   "id"=>1,
                   "project"=>{"name"=>"eCookbook", "id"=>1},
                   "roles"=>[{"name"=>"Manager", "id"=>1}]
                 }], json['user']['memberships']
               end
               test "GET /users/current.xml should require authentication" do
                 get '/users/current.xml'
                 assert_response 401
               end
               test "GET /users/current.xml should return current user" do
                 get '/users/current.xml', {}, credentials('jsmith')
                 assert_select 'user id', :text => '2'
               end
               test "GET /users/:id should not return login for other user" do
                 get '/users/3.xml', {}, credentials('jsmith')
                 assert_response :success
                 assert_select 'user login', 0
               end
               test "GET /users/:id should return login for current user" do
                 get '/users/2.xml', {}, credentials('jsmith')
                 assert_response :success
                 assert_select 'user login', :text => 'jsmith'
               end
               test "GET /users/:id should not return api_key for other user" do
                 get '/users/3.xml', {}, credentials('jsmith')
                 assert_response :success
                 assert_select 'user api_key', 0
               end
               test "GET /users/:id should return api_key for current user" do
                 get '/users/2.xml', {}, credentials('jsmith')
                 assert_response :success
                 assert_select 'user api_key', :text => User.find(2).api_key
               end
               test "GET /users/:id should not return status for standard user" do
                 get '/users/3.xml', {}, credentials('jsmith')
                 assert_response :success
                 assert_select 'user status', 0
               end
               test "GET /users/:id should return status for administrators" do
                 get '/users/2.xml', {}, credentials('admin')
                 assert_response :success
                 assert_select 'user status', :text => User.find(1).status.to_s
               end
               test "POST /users.xml with valid parameters should create the user" do
                 assert_difference('User.count') do
                   post '/users.xml', {
                     :user => {
                       :login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
                       :mail => 'foo@example.net', :password => 'secret123',
                       :mail_notification => 'only_assigned'}
                     },
                     credentials('admin')
                 end
                 user = User.order('id DESC').first
                 assert_equal 'foo', user.login
                 assert_equal 'Firstname', user.firstname
                 assert_equal 'Lastname', user.lastname
                 assert_equal 'foo@example.net', user.mail
                 assert_equal 'only_assigned', user.mail_notification
                 assert !user.admin?
                 assert user.check_password?('secret123')
                 assert_response :created
                 assert_equal 'application/xml', @response.content_type
                 assert_select 'user id', :text => user.id.to_s
               end
               test "POST /users.json with valid parameters should create the user" do
                 assert_difference('User.count') do
                   post '/users.json', {
                     :user => {
                       :login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
                       :mail => 'foo@example.net', :password => 'secret123',
                       :mail_notification => 'only_assigned'}
                     },
                     credentials('admin')
                 end
                 user = User.order('id DESC').first
                 assert_equal 'foo', user.login
                 assert_equal 'Firstname', user.firstname
                 assert_equal 'Lastname', user.lastname
                 assert_equal 'foo@example.net', user.mail
                 assert !user.admin?
                 assert_response :created
                 assert_equal 'application/json', @response.content_type
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_kind_of Hash, json
                 assert_kind_of Hash, json['user']
                 assert_equal user.id, json['user']['id']
               end
               test "POST /users.xml with with invalid parameters should return errors" do
                 assert_no_difference('User.count') do
                   post '/users.xml', {:user => {:login => 'foo', :lastname => 'Lastname', :mail => 'foo'}}, credentials('admin')
                 end
                 assert_response :unprocessable_entity
                 assert_equal 'application/xml', @response.content_type
                 assert_select 'errors error', :text => "First name cannot be blank"
               end
               test "POST /users.json with with invalid parameters should return errors" do
                 assert_no_difference('User.count') do
                   post '/users.json', {:user => {:login => 'foo', :lastname => 'Lastname', :mail => 'foo'}}, credentials('admin')
                 end
                 assert_response :unprocessable_entity
                 assert_equal 'application/json', @response.content_type
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_kind_of Hash, json
                 assert json.has_key?('errors')
                 assert_kind_of Array, json['errors']
               end
               test "PUT /users/:id.xml with valid parameters should update the user" do
                 assert_no_difference('User.count') do
                   put '/users/2.xml', {
                     :user => {
                       :login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
                       :mail => 'jsmith@somenet.foo'}
                     },
                     credentials('admin')
                 end
                 user = User.find(2)
                 assert_equal 'jsmith', user.login
                 assert_equal 'John', user.firstname
                 assert_equal 'Renamed', user.lastname
                 assert_equal 'jsmith@somenet.foo', user.mail
                 assert !user.admin?
                 assert_response :ok
                 assert_equal '', @response.body
               end
               test "PUT /users/:id.json with valid parameters should update the user" do
                 assert_no_difference('User.count') do
                   put '/users/2.json', {
                     :user => {
                       :login => 'jsmith', :firstname => 'John', :lastname => 'Renamed',
                       :mail => 'jsmith@somenet.foo'}
                     },
                     credentials('admin')
                 end
                 user = User.find(2)
                 assert_equal 'jsmith', user.login
                 assert_equal 'John', user.firstname
                 assert_equal 'Renamed', user.lastname
                 assert_equal 'jsmith@somenet.foo', user.mail
                 assert !user.admin?
                 assert_response :ok
                 assert_equal '', @response.body
               end
               test "PUT /users/:id.xml with invalid parameters" do
                 assert_no_difference('User.count') do
                   put '/users/2.xml', {
                     :user => {
                       :login => 'jsmith', :firstname => '', :lastname => 'Lastname',
                       :mail => 'foo'}
                     },
                     credentials('admin')
                 end
                 assert_response :unprocessable_entity
                 assert_equal 'application/xml', @response.content_type
                 assert_select 'errors error', :text => "First name cannot be blank"
               end
               test "PUT /users/:id.json with invalid parameters" do
                 assert_no_difference('User.count') do
                   put '/users/2.json', {
                     :user => {
                       :login => 'jsmith', :firstname => '', :lastname => 'Lastname',
                       :mail => 'foo'}
                     },
                     credentials('admin')
                 end
                 assert_response :unprocessable_entity
                 assert_equal 'application/json', @response.content_type
                 json = ActiveSupport::JSON.decode(response.body)
                 assert_kind_of Hash, json
                 assert json.has_key?('errors')
                 assert_kind_of Array, json['errors']
               end
               test "DELETE /users/:id.xml should delete the user" do
                 assert_difference('User.count', -1) do
                   delete '/users/2.xml', {}, credentials('admin')
                 end
                 assert_response :ok
                 assert_equal '', @response.body
               end
               test "DELETE /users/:id.json should delete the user" do
                 assert_difference('User.count', -1) do
                   delete '/users/2.json', {}, credentials('admin')
                 end
                 assert_response :ok
                 assert_equal '', @response.body
               end
             end

test/integration/issues_test.rb 0 -2

             # 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 IssuesTest < Redmine::IntegrationTest
               fixtures :projects,
                        :users, :email_addresses,
                        :roles,
                        :members,
                        :member_roles,
                        :trackers,
                        :projects_trackers,
                        :enabled_modules,
                        :issue_statuses,
                        :issues,
                        :enumerations,
                        :custom_fields,
                        :custom_values,
                        :custom_fields_trackers,
                        :attachments
               # create an issue
               def test_add_issue
                 log_user('jsmith', 'jsmith')
                 get '/projects/ecookbook/issues/new'
                 assert_response :success
-                assert_template 'issues/new'
                 issue = new_record(Issue) do
                   post '/projects/ecookbook/issues',
                                              :issue => { :tracker_id => "1",
                                                          :start_date => "2006-12-26",
                                                          :priority_id => "4",
                                                          :subject => "new test issue",
                                                          :category_id => "",
                                                          :description => "new issue",
                                                          :done_ratio => "0",
                                                          :due_date => "",
                                                          :assigned_to_id => "" },
                                              :custom_fields => {'2' => 'Value for field 2'}
                 end
                 # check redirection
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => issue
                 follow_redirect!
-                assert_equal issue, assigns(:issue)
                 # check issue attributes
                 assert_equal 'jsmith', issue.author.login
                 assert_equal 1, issue.project.id
                 assert_equal 1, issue.status.id
               end
               def test_create_issue_by_anonymous_without_permission_should_fail
                 Role.anonymous.remove_permission! :add_issues
                 assert_no_difference 'Issue.count' do
                   post '/projects/1/issues', :tracker_id => "1", :issue => {:subject => "new test issue"}
                 end
                 assert_response 302
               end
               def test_create_issue_by_anonymous_with_custom_permission_should_succeed
                 Role.anonymous.remove_permission! :add_issues
                 Member.create!(:project_id => 1, :principal => Group.anonymous, :role_ids => [3])
                 issue = new_record(Issue) do
                   post '/projects/1/issues', :tracker_id => "1", :issue => {:subject => "new test issue"}
                   assert_response 302
                 end
                 assert_equal User.anonymous, issue.author
               end
               # add then remove 2 attachments to an issue
               def test_issue_attachments
                 log_user('jsmith', 'jsmith')
                 set_tmp_attachments_directory
                 attachment = new_record(Attachment) do
                   put '/issues/1',
                        :notes => 'Some notes',
                        :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'This is an attachment'}}
                   assert_redirected_to "/issues/1"
                 end
                 assert_equal Issue.find(1), attachment.container
                 assert_equal 'testfile.txt', attachment.filename
                 assert_equal 'This is an attachment', attachment.description
                 # verify the size of the attachment stored in db
                 #assert_equal file_data_1.length, attachment.filesize
                 # verify that the attachment was written to disk
                 assert File.exist?(attachment.diskfile)
                 # remove the attachments
                 Issue.find(1).attachments.each(&:destroy)
                 assert_equal 0, Issue.find(1).attachments.length
               end
               def test_other_formats_links_on_index
                 get '/projects/ecookbook/issues'
                 %w(Atom PDF CSV).each do |format|
                   assert_select 'a[rel=nofollow][href=?]', "/projects/ecookbook/issues.#{format.downcase}", :text => format
                 end
               end
               def test_other_formats_links_on_index_without_project_id_in_url
                 get '/issues', :project_id => 'ecookbook'
                 %w(Atom PDF CSV).each do |format|
                   assert_select 'a[rel=nofollow][href=?]', "/issues.#{format.downcase}?project_id=ecookbook", :text => format
                 end
               end
               def test_pagination_links_on_index
                 with_settings :per_page_options => '2' do
                   get '/projects/ecookbook/issues'
                   assert_select 'a[href=?]', '/projects/ecookbook/issues?page=2', :text => '2'
                 end
               end
               def test_pagination_links_should_preserve_query_parameters
                 with_settings :per_page_options => '2' do
                   get '/projects/ecookbook/issues?foo=bar'
                   assert_select 'a[href=?]', '/projects/ecookbook/issues?foo=bar&page=2', :text => '2'
                 end
               end
               def test_pagination_links_should_not_use_params_as_url_options
                 with_settings :per_page_options => '2' do
                   get '/projects/ecookbook/issues?host=foo'
                   assert_select 'a[href=?]', '/projects/ecookbook/issues?host=foo&page=2', :text => '2'
                 end
               end
               def test_sort_links_on_index
                 get '/projects/ecookbook/issues'
                 assert_select 'a[href=?]', '/projects/ecookbook/issues?sort=subject%2Cid%3Adesc', :text => 'Subject'
               end
               def test_sort_links_should_preserve_query_parameters
                 get '/projects/ecookbook/issues?foo=bar'
                 assert_select 'a[href=?]', '/projects/ecookbook/issues?foo=bar&sort=subject%2Cid%3Adesc', :text => 'Subject'
               end
               def test_sort_links_should_not_use_params_as_url_options
                 get '/projects/ecookbook/issues?host=foo'
                 assert_select 'a[href=?]', '/projects/ecookbook/issues?host=foo&sort=subject%2Cid%3Adesc', :text => 'Subject'
               end
               def test_issue_with_user_custom_field
                 @field = IssueCustomField.create!(:name => 'Tester', :field_format => 'user', :is_for_all => true, :trackers => Tracker.all)
                 Role.anonymous.add_permission! :add_issues, :edit_issues
                 users = Project.find(1).users.sort
                 tester = users.first
                 # Issue form
                 get '/projects/ecookbook/issues/new'
                 assert_response :success
                 assert_select 'select[name=?]', "issue[custom_field_values][#{@field.id}]" do
                   assert_select 'option', users.size + 1 # +1 for blank value
                   assert_select 'option[value=?]', tester.id.to_s, :text => tester.name
                 end
                 # Create issue
                 issue = new_record(Issue) do
                   post '/projects/ecookbook/issues',
                     :issue => {
                       :tracker_id => '1',
                       :priority_id => '4',
                       :subject => 'Issue with user custom field',
                       :custom_field_values => {@field.id.to_s => users.first.id.to_s}
                     }
                   assert_response 302
                 end
                 # Issue view
                 follow_redirect!
                 assert_select ".cf_#{@field.id}" do
                   assert_select '.label', :text => 'Tester:'
                   assert_select '.value', :text => tester.name
                 end
                 assert_select 'select[name=?]', "issue[custom_field_values][#{@field.id}]" do
                   assert_select 'option', users.size + 1 # +1 for blank value
                   assert_select 'option[value=?][selected=selected]', tester.id.to_s, :text => tester.name
                 end
                 new_tester = users[1]
                 with_settings :default_language => 'en' do
                   # Update issue
                   assert_difference 'Journal.count' do
                     put "/issues/#{issue.id}",
                         :notes => 'Updating custom field',
                         :issue => {
                             :custom_field_values => {@field.id.to_s => new_tester.id.to_s}
                           }
                     assert_redirected_to "/issues/#{issue.id}"
                   end
                   # Issue view
                   follow_redirect!
                   assert_select 'ul.details li', :text => "Tester changed from #{tester} to #{new_tester}"
                 end
               end
               def test_update_using_invalid_http_verbs
                 subject = 'Updated by an invalid http verb'
                 get '/issues/update/1', {:issue => {:subject => subject}}, credentials('jsmith')
                 assert_response 404
                 assert_not_equal subject, Issue.find(1).subject
                 post '/issues/1', {:issue => {:subject => subject}}, credentials('jsmith')
                 assert_response 404
                 assert_not_equal subject, Issue.find(1).subject
               end
               def test_get_watch_should_be_invalid
                 assert_no_difference 'Watcher.count' do
                   get '/watchers/watch?object_type=issue&object_id=1', {}, credentials('jsmith')
                   assert_response 404
                 end
               end
             end

test/integration/projects_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 ProjectsTest < Redmine::IntegrationTest
               fixtures :projects, :users, :members, :enabled_modules
               def test_archive_project
                 subproject = Project.find(1).children.first
                 log_user("admin", "admin")
                 get "/admin/projects"
                 assert_response :success
-                assert_template "admin/projects"
                 post "/projects/1/archive"
                 assert_redirected_to "/admin/projects"
                 assert !Project.find(1).active?
                 get '/projects/1'
                 assert_response 403
                 get "/projects/#{subproject.id}"
                 assert_response 403
                 post "/projects/1/unarchive"
                 assert_redirected_to "/admin/projects"
                 assert Project.find(1).active?
                 get "/projects/1"
                 assert_response :success
               end
               def test_modules_should_not_allow_get
                 assert_no_difference 'EnabledModule.count' do
                   get '/projects/1/modules', {:enabled_module_names => ['']}, credentials('jsmith')
                   assert_response 404
                 end
               end
             end

test/integration/sudo_mode_test.rb +9 -9

             require File.expand_path('../../test_helper', __FILE__)
             class SudoModeTest < Redmine::IntegrationTest
               fixtures :projects, :members, :member_roles, :roles, :users, :email_addresses
               def setup
                 Redmine::SudoMode.stubs(:enabled?).returns(true)
               end
               def test_sudo_mode_should_be_active_after_login
                 log_user("admin", "admin")
                 get "/users/new"
                 assert_response :success
                 post "/users",
                      :user => { :login => "psmith", :firstname => "Paul",
                                 :lastname => "Smith", :mail => "psmith@somenet.foo",
                                 :language => "en", :password => "psmith09",
                                 :password_confirmation => "psmith09" }
                 assert_response 302
                 user = User.find_by_login("psmith")
                 assert_kind_of User, user
               end
               def test_add_user
                 log_user("admin", "admin")
                 expire_sudo_mode!
                 get "/users/new"
                 assert_response :success
                 post "/users",
                      :user => { :login => "psmith", :firstname => "Paul",
                                 :lastname => "Smith", :mail => "psmith@somenet.foo",
                                 :language => "en", :password => "psmith09",
                                 :password_confirmation => "psmith09" }
                 assert_response :success
                 assert_nil User.find_by_login("psmith")
                 assert_select 'input[name=?][value=?]', 'user[login]', 'psmith'
                 assert_select 'input[name=?][value=?]', 'user[firstname]', 'Paul'
                 post "/users",
                      :user => { :login => "psmith", :firstname => "Paul",
                                 :lastname => "Smith", :mail => "psmith@somenet.foo",
                                 :language => "en", :password => "psmith09",
                                 :password_confirmation => "psmith09" },
                      :sudo_password => 'admin'
                 assert_response 302
                 user = User.find_by_login("psmith")
                 assert_kind_of User, user
               end
               def test_create_member_xhr
                 log_user 'admin', 'admin'
                 expire_sudo_mode!
                 get '/projects/ecookbook/settings/members'
                 assert_response :success
                 assert_no_difference 'Member.count' do
                   xhr :post, '/projects/ecookbook/memberships', membership: {role_ids: [1], user_id: 7}
                 end
                 assert_no_difference 'Member.count' do
                   xhr :post, '/projects/ecookbook/memberships', membership: {role_ids: [1], user_id: 7}, sudo_password: ''
                 end
                 assert_no_difference 'Member.count' do
                   xhr :post, '/projects/ecookbook/memberships', membership: {role_ids: [1], user_id: 7}, sudo_password: 'wrong'
                 end
                 assert_difference 'Member.count' do
                   xhr :post, '/projects/ecookbook/memberships', membership: {role_ids: [1], user_id: 7}, sudo_password: 'admin'
                 end
                 assert User.find(7).member_of?(Project.find(1))
               end
               def test_create_member
                 log_user 'admin', 'admin'
                 expire_sudo_mode!
                 get '/projects/ecookbook/settings/members'
                 assert_response :success
                 assert_no_difference 'Member.count' do
                   post '/projects/ecookbook/memberships', membership: {role_ids: [1], user_id: 7}
                 end
                 assert_no_difference 'Member.count' do
                   post '/projects/ecookbook/memberships', membership: {role_ids: [1], user_id: 7}, sudo_password: ''
                 end
                 assert_no_difference 'Member.count' do
                   post '/projects/ecookbook/memberships', membership: {role_ids: [1], user_id: 7}, sudo_password: 'wrong'
                 end
                 assert_difference 'Member.count' do
                   post '/projects/ecookbook/memberships', membership: {role_ids: [1], user_id: 7}, sudo_password: 'admin'
                 end
                 assert_redirected_to '/projects/ecookbook/settings/members'
                 assert User.find(7).member_of?(Project.find(1))
               end
               def test_create_role
                 log_user 'admin', 'admin'
                 expire_sudo_mode!
                 get '/roles'
                 assert_response :success
                 get '/roles/new'
                 assert_response :success
                 post '/roles', role: { }
                 assert_response :success
                 assert_select 'h2', 'Confirm your password to continue'
                 assert_select 'form[action="/roles"]'
-                assert assigns(:sudo_form).errors.blank?
+                assert_select '#flash_error', 0
                 post '/roles', role: { name: 'new role', issues_visibility: 'all' }
                 assert_response :success
                 assert_select 'h2', 'Confirm your password to continue'
                 assert_select 'form[action="/roles"]'
-                assert_match /"new role"/, response.body
+                assert_select 'input[type=hidden][name=?][value=?]', 'role[name]', 'new role'
-                assert assigns(:sudo_form).errors.blank?
+                assert_select '#flash_error', 0
                 post '/roles', role: { name: 'new role', issues_visibility: 'all' }, sudo_password: 'wrong'
                 assert_response :success
                 assert_select 'h2', 'Confirm your password to continue'
                 assert_select 'form[action="/roles"]'
-                assert_match /"new role"/, response.body
+                assert_select 'input[type=hidden][name=?][value=?]', 'role[name]', 'new role'
-                assert assigns(:sudo_form).errors[:password].present?
+                assert_select '#flash_error'
                 assert_difference 'Role.count' do
                   post '/roles', role: { name: 'new role', issues_visibility: 'all', assignable: '1', permissions: %w(view_calendar) }, sudo_password: 'admin'
                 end
                 assert_redirected_to '/roles'
               end
               def test_update_email_address
                 log_user 'jsmith', 'jsmith'
                 expire_sudo_mode!
                 get '/my/account'
                 assert_response :success
                 post '/my/account', user: { mail: 'newmail@test.com' }
                 assert_response :success
                 assert_select 'h2', 'Confirm your password to continue'
                 assert_select 'form[action="/my/account"]'
-                assert_match /"newmail@test\.com"/, response.body
+                assert_select 'input[type=hidden][name=?][value=?]', 'user[mail]', 'newmail@test.com'
-                assert assigns(:sudo_form).errors.blank?
+                assert_select '#flash_error', 0
                 # wrong password
                 post '/my/account', user: { mail: 'newmail@test.com' }, sudo_password: 'wrong'
                 assert_response :success
                 assert_select 'h2', 'Confirm your password to continue'
                 assert_select 'form[action="/my/account"]'
-                assert_match /"newmail@test\.com"/, response.body
+                assert_select 'input[type=hidden][name=?][value=?]', 'user[mail]', 'newmail@test.com'
-                assert assigns(:sudo_form).errors[:password].present?
+                assert_select '#flash_error'
                 # correct password
                 post '/my/account', user: { mail: 'newmail@test.com' }, sudo_password: 'jsmith'
                 assert_redirected_to '/my/account'
                 assert_equal 'newmail@test.com', User.find_by_login('jsmith').mail
                 # sudo mode should now be active and not require password again
                 post '/my/account', user: { mail: 'even.newer.mail@test.com' }
                 assert_redirected_to '/my/account'
                 assert_equal 'even.newer.mail@test.com', User.find_by_login('jsmith').mail
               end
               def test_sudo_mode_should_skip_api_requests
                 with_settings :rest_api_enabled => '1' do
                   assert_difference('User.count') do
                     post '/users.json', {
                       :user => {
                         :login => 'foo', :firstname => 'Firstname', :lastname => 'Lastname',
                         :mail => 'foo@example.net', :password => 'secret123',
                         :mail_notification => 'only_assigned'}
                       },
                       credentials('admin')
                     assert_response :created
                   end
                 end
               end
               private
               # sudo mode is active after sign, let it expire by advancing the time
               def expire_sudo_mode!
                 travel_to 20.minutes.from_now
               end
             end

test/test_helper.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.
             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 HelperTest < ActionView::TestCase
               end
               class ControllerTest < ActionController::TestCase
                 # Returns the issues that are displayed in the list in the same order
                 def issues_in_list
                   ids = css_select('tr.issue td.id').map(&:text).map(&:to_i)
                   Issue.where(:id => ids).sort_by {|issue| ids.index(issue.id)}
                 end
                 # Return the columns that are displayed in the list
                 def columns_in_issues_list
                   css_select('table.issues thead th:not(.checkbox)').map(&:text)
                 end
                 # Verifies that the query filters match the expected filters
                 def assert_query_filters(expected_filters)
                   response.body =~ /initFilters\(\);\s*((addFilter\(.+\);\s*)*)/
                   filter_init = $1.to_s
                   expected_filters.each do |field, operator, values|
                     s = "addFilter(#{field.to_json}, #{operator.to_json}, #{Array(values).to_json});"
                     assert_include s, filter_init
                   end
                   assert_equal expected_filters.size, filter_init.scan("addFilter").size, "filters counts don't match"
                 end
                 def process(method, path, parameters={}, session={}, flash={})
                   if parameters.key?(:params) || parameters.key?(:session)
                     raise ArgumentError if session.present?
                     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