jro_apps/redmine Commit - r15342:29ddc82a11f3

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

Jean-Philippe Lang -

r15342:29ddc82a11f3

parent child

Context file:

r15342:29ddc82a11f3

Collapse all files

test/fixtures/wiki_content_versions.yml +6 -5

              ---
              wiki_content_versions_001:
                updated_on: 2007-03-07 00:08:07 +01:00
                page_id: 1
                id: 1
                version: 1
                author_id: 2
                comments: Page creation
                wiki_content_id: 1
                compression: ""
                data: |-
-                 h1. CookBook documentation
+                 h1. CookBook documentation v1
+                 Line from v1
                  Some [[documentation]] here...
              wiki_content_versions_002:
                updated_on: 2007-03-07 00:08:34 +01:00
                page_id: 1
                id: 2
                version: 2
                author_id: 1
                comments: Small update
                wiki_content_id: 1
                compression: ""
                data: |-
-                 h1. CookBook documentation
+                 h1. CookBook documentation v2
+                 Line from v1
                  Some updated [[documentation]] here...
              wiki_content_versions_003:
                updated_on: 2007-03-07 00:10:51 +01:00
                page_id: 1
                id: 3
                version: 3
                author_id: 1
                comments: ""
                wiki_content_id: 1
                compression: ""
                data: |-
-                 h1. CookBook documentation
+                 h1. CookBook documentation v3
                  Some updated [[documentation]] here...
              wiki_content_versions_004:
                data: |-
                  h1. Another page
                  This is a link to a ticket: #2
                updated_on: 2007-03-08 00:18:07 +01:00
                page_id: 2
                wiki_content_id: 2
                id: 4
                version: 1
                author_id: 1
                comments:
              wiki_content_versions_005:
                data: |-
                  h1. Title
                  Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas sed libero.
                  h2. Heading 1
                  @WHATEVER@
                  Maecenas sed elit sit amet mi accumsan vestibulum non nec velit. Proin porta tincidunt lorem, consequat rhoncus dolor fermentum in.
                  Cras ipsum felis, ultrices at porttitor vel, faucibus eu nunc.
                  h2. Heading 2
                  Morbi facilisis accumsan orci non pharetra.
                updated_on: 2007-03-08 00:16:07 +01:00
                page_id: 11
                wiki_content_id: 11
                id: 5
                version: 2
                author_id: 1
                comments:
              wiki_content_versions_006:
                data: |-
                  h1. Title
                  Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas sed libero.
                  h2. Heading 1
                  @WHATEVER@
                  Maecenas sed elit sit amet mi accumsan vestibulum non nec velit. Proin porta tincidunt lorem, consequat rhoncus dolor fermentum in.
                  h2. Heading 2
                  Morbi facilisis accumsan orci non pharetra.
                updated_on: 2007-03-08 00:18:07 +01:00
                page_id: 11
                wiki_content_id: 11
                id: 6
                version: 3
                author_id: 1
                comments:
              wiki_content_versions_007:
                data: |-
                  h1. Page with an inline image
                  This is an inline image:
                  !logo.gif!
                updated_on: 2007-03-08 00:18:07 +01:00
                page_id: 4
                wiki_content_id: 4
                id: 7
                version: 1
                author_id: 1
                comments:

test/functional/boards_controller_test.rb +3 -4

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../test_helper', __FILE__)
              class BoardsControllerTest < Redmine::ControllerTest
                fixtures :projects, :users, :members, :member_roles, :roles, :boards, :messages, :enabled_modules
                def setup
                  User.current = nil
                end
                def test_index
                  get :index, :project_id => 1
                  assert_response :success
                  assert_select 'table.boards'
                end
                def test_index_not_found
                  get :index, :project_id => 97
                  assert_response 404
                end
                def test_index_should_show_messages_if_only_one_board
                  Project.find(1).boards.slice(1..-1).each(&:destroy)
                  get :index, :project_id => 1
                  assert_response :success
                  assert_select 'table.boards', 0
                  assert_select 'table.messages'
                end
                def test_show
                  get :show, :project_id => 1, :id => 1
                  assert_response :success
                  assert_select 'table.messages tbody' do
                    assert_select 'tr', Board.find(1).topics.count
                  end
                end
                def test_show_should_display_sticky_messages_first
                  Message.update_all(:sticky => 0)
                  Message.where({:id => 1}).update_all({:sticky => 1})
                  get :show, :project_id => 1, :id => 1
                  assert_response :success
                  assert_select 'table.messages tbody' do
                    # row is here...
                    assert_select 'tr.sticky'
                    # ...and in first position
                    assert_select 'tr.sticky:first-child'
                  end
                end
                def test_show_should_display_message_with_last_reply_first
                  Message.update_all(:sticky => 0)
                  # Reply to an old topic
                  old_topic = Message.where(:board_id => 1, :parent_id => nil).order('created_on ASC').first
                  reply = Message.new(:board_id => 1, :subject => 'New reply', :content => 'New reply', :author_id => 2)
                  old_topic.children << reply
                  get :show, :project_id => 1, :id => 1
                  assert_response :success
                  assert_select 'table.messages tbody' do
                    assert_select "tr#message-#{old_topic.id}"
                    assert_select "tr#message-#{old_topic.id}:first-child"
                  end
                end
                def test_show_with_permission_should_display_the_new_message_form
                  @request.session[:user_id] = 2
                  get :show, :project_id => 1, :id => 1
                  assert_response :success
                  assert_select 'form#message-form' do
                    assert_select 'input[name=?]', 'message[subject]'
                  end
                end
                def test_show_atom
                  get :show, :project_id => 1, :id => 1, :format => 'atom'
                  assert_response :success
                  assert_select 'feed > entry > title', :text => 'Help: RE: post 2'
                end
                def test_show_not_found
                  get :index, :project_id => 1, :id => 97
                  assert_response 404
                end
                def test_new
                  @request.session[:user_id] = 2
                  get :new, :project_id => 1
                  assert_response :success
                  assert_select 'select[name=?]', 'board[parent_id]' do
                    assert_select 'option', (Project.find(1).boards.size + 1)
                    assert_select 'option[value=""]'
                    assert_select 'option[value="1"]', :text => 'Help'
                  end
                  # &nbsp; replaced by nokogiri, not easy to test in DOM assertions
                  assert_not_include '<option value=""></option>', response.body
                  assert_include '<option value="">&nbsp;</option>', response.body
                end
                def test_new_without_project_boards
                  Project.find(1).boards.delete_all
                  @request.session[:user_id] = 2
                  get :new, :project_id => 1
                  assert_response :success
                  assert_select 'select[name=?]', 'board[parent_id]', 0
                end
                def test_create
                  @request.session[:user_id] = 2
                  assert_difference 'Board.count' do
                    post :create, :project_id => 1, :board => { :name => 'Testing', :description => 'Testing board creation'}
                  end
                  assert_redirected_to '/projects/ecookbook/settings/boards'
                  board = Board.order('id DESC').first
                  assert_equal 'Testing', board.name
                  assert_equal 'Testing board creation', board.description
                end
                def test_create_with_parent
                  @request.session[:user_id] = 2
                  assert_difference 'Board.count' do
                    post :create, :project_id => 1, :board => { :name => 'Testing', :description => 'Testing', :parent_id => 2}
                  end
                  assert_redirected_to '/projects/ecookbook/settings/boards'
                  board = Board.order('id DESC').first
                  assert_equal Board.find(2), board.parent
                end
                def test_create_with_failure
                  @request.session[:user_id] = 2
                  assert_no_difference 'Board.count' do
                    post :create, :project_id => 1, :board => { :name => '', :description => 'Testing board creation'}
                  end
                  assert_response :success
-                 assert_template 'new'
+                 assert_select_error /Name cannot be blank/
                end
                def test_edit
                  @request.session[:user_id] = 2
                  get :edit, :project_id => 1, :id => 2
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select 'input[name=?][value=?]', 'board[name]', 'Discussion'
                end
                def test_edit_with_parent
                  board = Board.generate!(:project_id => 1, :parent_id => 2)
                  @request.session[:user_id] = 2
                  get :edit, :project_id => 1, :id => board.id
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'select[name=?]', 'board[parent_id]' do
                    assert_select 'option[value="2"][selected=selected]'
                  end
                end
                def test_update
                  @request.session[:user_id] = 2
                  assert_no_difference 'Board.count' do
                    put :update, :project_id => 1, :id => 2, :board => { :name => 'Testing', :description => 'Testing board update'}
                  end
                  assert_redirected_to '/projects/ecookbook/settings/boards'
                  assert_equal 'Testing', Board.find(2).name
                end
                def test_update_position
                  @request.session[:user_id] = 2
                  put :update, :project_id => 1, :id => 2, :board => { :position => 1}
                  assert_redirected_to '/projects/ecookbook/settings/boards'
                  board = Board.find(2)
                  assert_equal 1, board.position
                end
                def test_update_with_failure
                  @request.session[:user_id] = 2
                  put :update, :project_id => 1, :id => 2, :board => { :name => '', :description => 'Testing board update'}
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select_error /Name cannot be blank/
                end
                def test_destroy
                  @request.session[:user_id] = 2
                  assert_difference 'Board.count', -1 do
                    delete :destroy, :project_id => 1, :id => 2
                  end
                  assert_redirected_to '/projects/ecookbook/settings/boards'
                  assert_nil Board.find_by_id(2)
                end
              end

test/functional/roles_controller_test.rb +12 -20

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

test/functional/search_controller_test.rb +140 -84

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

test/functional/search_custom_fields_visibility_test.rb +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 SearchCustomFieldsVisibilityTest < Redmine::ControllerTest
                tests SearchController
                fixtures :projects,
                         :users,
                         :roles,
                         :members,
                         :member_roles,
                         :issue_statuses,
                         :trackers,
                         :projects_trackers,
                         :enabled_modules,
                         :enumerations,
                         :workflows
                def setup
                  field_attributes = {:field_format => 'string', :is_for_all => true, :is_filter => true, :searchable => true, :trackers => Tracker.all}
                  @fields = []
                  @fields << (@field1 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 1', :visible => true)))
                  @fields << (@field2 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 2', :visible => false, :role_ids => [1, 2])))
                  @fields << (@field3 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 3', :visible => false, :role_ids => [1, 3])))
                  @issue = Issue.generate!(
                    :author_id => 1,
                    :project_id => 1,
                    :tracker_id => 1,
                    :custom_field_values => {@field1.id => 'Value0', @field2.id => 'Value1', @field3.id => 'Value2'}
                  )
                  @user_with_role_on_other_project = User.generate!
                  User.add_to_project(@user_with_role_on_other_project, Project.find(2), Role.find(3))
                  @users_to_test = {
                    User.find(1) => [@field1, @field2, @field3],
                    User.find(3) => [@field1, @field2],
                    @user_with_role_on_other_project => [@field1], # should see field1 only on Project 1
                    User.generate! => [@field1],
                    User.anonymous => [@field1]
                  }
                  Member.where(:project_id => 1).each do |member|
                    member.destroy unless @users_to_test.keys.include?(member.principal)
                  end
                end
                def test_search_should_search_visible_custom_fields_only
                  @users_to_test.each do |user, fields|
                    @request.session[:user_id] = user.id
                    @fields.each_with_index do |field, i|
                      get :index, :params => {:q => "value#{i}"}
                      assert_response :success
                      # we should get a result only if the custom field is visible
                      if fields.include?(field)
-                       assert_equal 1, assigns(:results).size
+                       assert_select '#search-results dt', 1
                      else
-                       assert_equal 0, assigns(:results).size
+                       assert_select '#search-results dt', 0
                      end
                    end
                  end
                end
              end

test/functional/settings_controller_test.rb +3 -3

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

test/functional/time_entry_reports_controller_test.rb +11 -29

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

test/functional/timelog_controller_test.rb +37 -44

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

test/functional/timelog_custom_fields_visibility_test.rb +4 -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 TimelogCustomFieldsVisibilityTest < Redmine::ControllerTest
                tests TimelogController
                fixtures :projects,
                         :users,
                         :roles,
                         :members,
                         :member_roles,
                         :issue_statuses,
                         :trackers,
                         :projects_trackers,
                         :enabled_modules,
                         :enumerations,
                         :workflows
                def setup
                  field_attributes = {:field_format => 'string', :is_for_all => true, :is_filter => true, :trackers => Tracker.all}
                  @fields = []
                  @fields << (@field1 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 1', :visible => true)))
                  @fields << (@field2 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 2', :visible => false, :role_ids => [1, 2])))
                  @fields << (@field3 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 3', :visible => false, :role_ids => [1, 3])))
                  @issue = Issue.generate!(
                    :author_id => 1,
                    :project_id => 1,
                    :tracker_id => 1,
                    :custom_field_values => {@field1.id => 'Value0', @field2.id => 'Value1', @field3.id => 'Value2'}
                  )
                  TimeEntry.generate!(:issue => @issue)
                  @user_with_role_on_other_project = User.generate!
                  User.add_to_project(@user_with_role_on_other_project, Project.find(2), Role.find(3))
                  @users_to_test = {
                    User.find(1) => [@field1, @field2, @field3],
                    User.find(3) => [@field1, @field2],
                    @user_with_role_on_other_project => [@field1], # should see field1 only on Project 1
                    User.generate! => [@field1],
                    User.anonymous => [@field1]
                  }
                  Member.where(:project_id => 1).each do |member|
                    member.destroy unless @users_to_test.keys.include?(member.principal)
                  end
                end
                def test_index_should_show_visible_custom_fields_only
                  @users_to_test.each do |user, fields|
                    @request.session[:user_id] = user.id
                    get :index, :params => {
                      :project_id => 1,
                      :issue_id => @issue.id,
                      :c => (['hours'] + @fields.map{|f| "issue.cf_#{f.id}"})
                    }
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
                        assert_select 'td', {:text => "Value#{i}", :count => 1}, "User #{user.id} was not able to view #{field.name}"
                      else
                        assert_select 'td', {:text => "Value#{i}", :count => 0}, "User #{user.id} was able to view #{field.name}"
                      end
                    end
                  end
                end
                def test_index_as_csv_should_show_visible_custom_fields_only
                  @users_to_test.each do |user, fields|
                    @request.session[:user_id] = user.id
                    get :index, :params => {
                      :project_id => 1,
                      :issue_id => @issue.id,
                      :c => (['hours'] + @fields.map{|f| "issue.cf_#{f.id}"}),
                      :format => 'csv'
                    }
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
                        assert_include "Value#{i}", response.body, "User #{user.id} was not able to view #{field.name} in CSV"
                      else
                        assert_not_include "Value#{i}", response.body, "User #{user.id} was able to view #{field.name} in CSV"
                      end
                    end
                  end
                end
                def test_index_with_partial_custom_field_visibility_should_show_visible_custom_fields_only
                  Issue.delete_all
                  TimeEntry.delete_all
                  p1 = Project.generate!
                  p2 = Project.generate!
                  user = User.generate!
                  User.add_to_project(user, p1, Role.where(:id => [1, 3]).to_a)
                  User.add_to_project(user, p2, Role.where(:id => 3).to_a)
                  TimeEntry.generate!(
                    :issue => Issue.generate!(:project => p1, :tracker_id => 1,
                                              :custom_field_values => {@field2.id => 'ValueA'}))
                  TimeEntry.generate!(
                    :issue => Issue.generate!(:project => p2, :tracker_id => 1,
                                              :custom_field_values => {@field2.id => 'ValueB'}))
                  TimeEntry.generate!(
                    :issue => Issue.generate!(:project => p1, :tracker_id => 1,
                                              :custom_field_values => {@field2.id => 'ValueC'}))
                  @request.session[:user_id] = user.id
                  get :index, :params => {:c => ["hours", "issue.cf_#{@field2.id}"]}
                  assert_select 'td', {:text => 'ValueA'}, "ValueA not found in:\n#{response.body}"
                  assert_select 'td', :text => 'ValueB', :count => 0
                  assert_select 'td', {:text => 'ValueC'}, "ValueC not found in:\n#{response.body}"
-                 get :index, :params => {:set_filter => '1', "issue.cf_#{@field2.id}" => '*'}
-                 assert_equal %w(ValueA ValueC), assigns(:entries).map{|i| i.issue.custom_field_value(@field2)}.sort
+                 get :index, :params => {:set_filter => '1', "issue.cf_#{@field2.id}" => '*', :c => ["issue.cf_#{@field2.id}"]}
+                 assert_select 'td', :text => "ValueA"
+                 assert_select 'td', :text => "ValueC"
+                 assert_select 'td', :text => "ValueB", :count => 0
                end
              end

test/functional/trackers_controller_test.rb +3 -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 TrackersControllerTest < Redmine::ControllerTest
                fixtures :trackers, :projects, :projects_trackers, :users, :issues, :custom_fields, :issue_statuses
                def setup
                  User.current = nil
                  @request.session[:user_id] = 1 # admin
                end
                def test_index
                  get :index
                  assert_response :success
-                 assert_template 'index'
+                 assert_select 'table.trackers'
                end
                def test_index_by_anonymous_should_redirect_to_login_form
                  @request.session[:user_id] = nil
                  get :index
                  assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Ftrackers'
                end
                def test_index_by_user_should_respond_with_406
                  @request.session[:user_id] = 2
                  get :index
                  assert_response 406
                end
                def test_new
                  get :new
                  assert_response :success
-                 assert_template 'new'
+                 assert_select 'input[name=?]', 'tracker[name]'
                end
                def test_create
                  assert_difference 'Tracker.count' do
                    post :create, :params => {
                      :tracker => {
                        :name => 'New tracker',
                        :default_status_id => 1,
                        :project_ids => ['1', '', ''],
                        :custom_field_ids => ['1', '6', '']
                      }
                    }
                  end
                  assert_redirected_to :action => 'index'
                  tracker = Tracker.order('id DESC').first
                  assert_equal 'New tracker', tracker.name
                  assert_equal [1], tracker.project_ids.sort
                  assert_equal Tracker::CORE_FIELDS, tracker.core_fields
                  assert_equal [1, 6], tracker.custom_field_ids.sort
                  assert_equal 0, tracker.workflow_rules.count
                end
                def test_create_with_disabled_core_fields
                  assert_difference 'Tracker.count' do
                    post :create, :params => {
                      :tracker => {
                        :name => 'New tracker',
                        :default_status_id => 1,
                        :core_fields => ['assigned_to_id', 'fixed_version_id', '']
                      }
                    }
                  end
                  assert_redirected_to :action => 'index'
                  tracker = Tracker.order('id DESC').first
                  assert_equal 'New tracker', tracker.name
                  assert_equal %w(assigned_to_id fixed_version_id), tracker.core_fields
                end
                def test_create_new_with_workflow_copy
                  assert_difference 'Tracker.count' do
                    post :create, :params => {
                      :tracker => {
                        :name => 'New tracker',
                        :default_status_id => 1
                      },
                      :copy_workflow_from => 1
                    }
                  end
                  assert_redirected_to :action => 'index'
                  tracker = Tracker.find_by_name('New tracker')
                  assert_equal 0, tracker.projects.count
                  assert_equal Tracker.find(1).workflow_rules.count, tracker.workflow_rules.count
                end
                def test_create_with_failure
                  assert_no_difference 'Tracker.count' do
                    post :create, :params => {
                      :tracker => {
                        :name => '',
                        :project_ids => ['1', '', ''],
                        :custom_field_ids => ['1', '6', '']
                      }
                    }
                  end
                  assert_response :success
-                 assert_template 'new'
                  assert_select_error /name cannot be blank/i
                end
                def test_edit
                  Tracker.find(1).project_ids = [1, 3]
                  get :edit, :params => {:id => 1}
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'input[name=?][value="1"][checked=checked]', 'tracker[project_ids][]'
                  assert_select 'input[name=?][value="2"]:not([checked])', 'tracker[project_ids][]'
                  assert_select 'input[name=?][value=""][type=hidden]', 'tracker[project_ids][]'
                end
                def test_edit_should_check_core_fields
                  tracker = Tracker.find(1)
                  tracker.core_fields = %w(assigned_to_id fixed_version_id)
                  tracker.save!
                  get :edit, :params => {:id => 1}
                  assert_response :success
-                 assert_template 'edit'
                  assert_select 'input[name=?][value=assigned_to_id][checked=checked]', 'tracker[core_fields][]'
                  assert_select 'input[name=?][value=fixed_version_id][checked=checked]', 'tracker[core_fields][]'
                  assert_select 'input[name=?][value=category_id]', 'tracker[core_fields][]'
                  assert_select 'input[name=?][value=category_id][checked=checked]', 'tracker[core_fields][]', 0
                  assert_select 'input[name=?][value=""][type=hidden]', 'tracker[core_fields][]'
                end
                def test_update
                  put :update, :params => {
                    :id => 1,
                    :tracker => {
                      :name => 'Renamed',
                      :project_ids => ['1', '2', '']
                    }
                  }
                  assert_redirected_to :action => 'index'
                  assert_equal [1, 2], Tracker.find(1).project_ids.sort
                end
                def test_update_without_projects
                  put :update, :params => {
                    :id => 1,
                    :tracker => {
                      :name => 'Renamed',
                      :project_ids => ['']
                    }
                  }
                  assert_redirected_to :action => 'index'
                  assert Tracker.find(1).project_ids.empty?
                end
                def test_update_without_core_fields
                  put :update, :params => {
                    :id => 1,
                    :tracker => {
                      :name => 'Renamed',
                      :core_fields => ['']
                    }
                  }
                  assert_redirected_to :action => 'index'
                  assert Tracker.find(1).core_fields.empty?
                end
                def test_update_with_failure
                  put :update, :params => {:id => 1, :tracker => { :name => '' }}
                  assert_response :success
-                 assert_template 'edit'
                  assert_select_error /name cannot be blank/i
                end
                def test_move_lower
                 tracker = Tracker.find_by_position(1)
                 put :update, :params => {:id => 1, :tracker => { :position => '2' }}
                 assert_equal 2, tracker.reload.position
                end
                def test_destroy
                  tracker = Tracker.generate!(:name => 'Destroyable')
                  assert_difference 'Tracker.count', -1 do
                    delete :destroy, :params => {:id => tracker.id}
                  end
                  assert_redirected_to :action => 'index'
                  assert_nil flash[:error]
                end
                def test_destroy_tracker_in_use
                  assert_no_difference 'Tracker.count' do
                    delete :destroy, :params => {:id => 1}
                  end
                  assert_redirected_to :action => 'index'
                  assert_not_nil flash[:error]
                end
                def test_get_fields
                  get :fields
                  assert_response :success
-                 assert_template 'fields'
                  assert_select 'form' do
                    assert_select 'input[type=checkbox][name=?][value=assigned_to_id]', 'trackers[1][core_fields][]'
                    assert_select 'input[type=checkbox][name=?][value="2"]', 'trackers[1][custom_field_ids][]'
                    assert_select 'input[type=hidden][name=?][value=""]', 'trackers[1][core_fields][]'
                    assert_select 'input[type=hidden][name=?][value=""]', 'trackers[1][custom_field_ids][]'
                  end
                end
                def test_post_fields
                  post :fields, :params => {
                    :trackers => {
                      '1' => {'core_fields' => ['assigned_to_id', 'due_date', ''], 'custom_field_ids' => ['1', '2']},
                      '2' => {'core_fields' => [''], 'custom_field_ids' => ['']}
                    }
                  }
                  assert_redirected_to '/trackers/fields'
                  tracker = Tracker.find(1)
                  assert_equal %w(assigned_to_id due_date), tracker.core_fields
                  assert_equal [1, 2], tracker.custom_field_ids.sort
                  tracker = Tracker.find(2)
                  assert_equal [], tracker.core_fields
                  assert_equal [], tracker.custom_field_ids.sort
                end
              end

test/functional/users_controller_test.rb +26 -35

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../test_helper', __FILE__)
              class UsersControllerTest < Redmine::ControllerTest
                include Redmine::I18n
                fixtures :users, :email_addresses, :projects, :members, :member_roles, :roles,
                         :custom_fields, :custom_values, :groups_users,
                         :auth_sources,
                         :enabled_modules,
                         :issues, :issue_statuses,
                         :trackers
                def setup
                  User.current = nil
                  @request.session[:user_id] = 1 # admin
                end
                def test_index
                  get :index
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:users)
-                 # active users only
-                 assert_nil assigns(:users).detect {|u| !u.active?}
+                 assert_select 'table.users'
+                 assert_select 'tr.user.active'
+                 assert_select 'tr.user.locked', 0
                end
                def test_index_with_status_filter
                  get :index, :params => {:status => 3}
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:users)
-                 assert_equal [3], assigns(:users).map(&:status).uniq
+                 assert_select 'tr.user.active', 0
+                 assert_select 'tr.user.locked'
                end
                def test_index_with_name_filter
                  get :index, :params => {:name => 'john'}
                  assert_response :success
-                 assert_template 'index'
-                 users = assigns(:users)
-                 assert_not_nil users
-                 assert_equal 1, users.size
-                 assert_equal 'John', users.first.firstname
+                 assert_select 'tr.user td.username', :text => 'jsmith'
+                 assert_select 'tr.user', 1
                end
                def test_index_with_group_filter
                  get :index, :params => {:group_id => '10'}
                  assert_response :success
-                 assert_template 'index'
-                 users = assigns(:users)
-                 assert users.any?
-                 assert_equal([], (users - Group.find(10).users))
+                 assert_select 'tr.user', Group.find(10).users.count
                  assert_select 'select[name=group_id]' do
                    assert_select 'option[value="10"][selected=selected]'
                  end
                end
                def test_show
                  @request.session[:user_id] = nil
                  get :show, :params => {:id => 2}
                  assert_response :success
-                 assert_template 'show'
-                 assert_not_nil assigns(:user)
+                 assert_select 'h2', :text => /John Smith/
+               end
+               def test_show_should_display_visible_custom_fields
+                 @request.session[:user_id] = nil
+                 UserCustomField.find_by_name('Phone number').update_attribute :visible, true
+                 get :show, :params => {:id => 2}
+                 assert_response :success
                  assert_select 'li', :text => /Phone number/
                end
                def test_show_should_not_display_hidden_custom_fields
                  @request.session[:user_id] = nil
                  UserCustomField.find_by_name('Phone number').update_attribute :visible, false
                  get :show, :params => {:id => 2}
                  assert_response :success
-                 assert_template 'show'
-                 assert_not_nil assigns(:user)
                  assert_select 'li', :text => /Phone number/, :count => 0
                end
                def test_show_should_not_fail_when_custom_values_are_nil
                  user = User.find(2)
                  # Create a custom field to illustrate the issue
                  custom_field = CustomField.create!(:name => 'Testing', :field_format => 'text')
                  custom_value = user.custom_values.build(:custom_field => custom_field).save!
                  get :show, :params => {:id => 2}
                  assert_response :success
                end
                def test_show_inactive
                  @request.session[:user_id] = nil
                  get :show, :params => {:id => 5}
                  assert_response 404
                end
                def test_show_inactive_by_admin
                  @request.session[:user_id] = 1
                  get :show, :params => {:id => 5}
                  assert_response 200
-                 assert_not_nil assigns(:user)
+                 assert_select 'h2', :text => /Dave2 Lopper2/
                end
                def test_show_user_who_is_not_visible_should_return_404
                  Role.anonymous.update! :users_visibility => 'members_of_visible_projects'
                  user = User.generate!
                  @request.session[:user_id] = nil
                  get :show, :params => {:id => user.id}
                  assert_response 404
                end
                def test_show_displays_memberships_based_on_project_visibility
                  @request.session[:user_id] = 1
                  get :show, :params => {:id => 2}
                  assert_response :success
-                 memberships = assigns(:memberships)
-                 assert_not_nil memberships
-                 project_ids = memberships.map(&:project_id)
-                 assert project_ids.include?(2) #private project admin can see
+                 # membership of private project admin can see
+                 assert_select 'li a', :text => "OnlineStore"
                end
                def test_show_current_should_require_authentication
                  @request.session[:user_id] = nil
                  get :show, :params => {:id => 'current'}
                  assert_response 302
                end
                def test_show_current
                  @request.session[:user_id] = 2
                  get :show, :params => {:id => 'current'}
                  assert_response :success
-                 assert_template 'show'
-                 assert_equal User.find(2), assigns(:user)
+                 assert_select 'h2', :text => /John Smith/
                end
                def test_new
                  get :new
                  assert_response :success
-                 assert_template :new
-                 assert assigns(:user)
+                 assert_select 'input[name=?]', 'user[login]'
                end
                def test_create
                  Setting.bcc_recipients = '1'
                  assert_difference 'User.count' do
                    assert_difference 'ActionMailer::Base.deliveries.size' do
                      post :create, :params => {
                        :user => {
                          :firstname => 'John',
                          :lastname => 'Doe',
                          :login => 'jdoe',
                          :password => 'secret123',
                          :password_confirmation => 'secret123',
                          :mail => 'jdoe@gmail.com',
                          :mail_notification => 'none'
                        },
                        :send_information => '1'
                      }
                    end
                  end
                  user = User.order('id DESC').first
                  assert_redirected_to :controller => 'users', :action => 'edit', :id => user.id
                  assert_equal 'John', user.firstname
                  assert_equal 'Doe', user.lastname
                  assert_equal 'jdoe', user.login
                  assert_equal 'jdoe@gmail.com', user.mail
                  assert_equal 'none', user.mail_notification
                  assert user.check_password?('secret123')
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  assert_equal [user.mail], mail.bcc
                  assert_mail_body_match 'secret', mail
                end
                def test_create_with_preferences
                  assert_difference 'User.count' do
                    post :create, :params => {
                      :user => {
                        :firstname => 'John',
                        :lastname => 'Doe',
                        :login => 'jdoe',
                        :password => 'secret123',
                        :password_confirmation => 'secret123',
                        :mail => 'jdoe@gmail.com',
                        :mail_notification => 'none'
                      },
                      :pref => {
                        'hide_mail' => '1',
                        'time_zone' => 'Paris',
                        'comments_sorting' => 'desc',
                        'warn_on_leaving_unsaved' => '0'
                      }
                    }
                  end
                  user = User.order('id DESC').first
                  assert_equal 'jdoe', user.login
                  assert_equal true, user.pref.hide_mail
                  assert_equal 'Paris', user.pref.time_zone
                  assert_equal 'desc', user.pref[:comments_sorting]
                  assert_equal '0', user.pref[:warn_on_leaving_unsaved]
                end
                def test_create_with_generate_password_should_email_the_password
                  assert_difference 'User.count' do
                    post :create, :params => {
                      :user => {
                        :login => 'randompass',
                        :firstname => 'Random',
                        :lastname => 'Pass',
                        :mail => 'randompass@example.net',
                        :language => 'en',
                        :generate_password => '1',
                        :password => '',
                        :password_confirmation => ''
                      },
                      :send_information => 1
                    }
                  end
                  user = User.order('id DESC').first
                  assert_equal 'randompass', user.login
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  m = mail_body(mail).match(/Password: ([a-zA-Z0-9]+)/)
                  assert m
                  password = m[1]
                  assert user.check_password?(password)
                end
                def test_create_and_continue
                  post :create, :params => {
                    :user => {
                      :login => 'randompass',
                      :firstname => 'Random',
                      :lastname => 'Pass',
                      :mail => 'randompass@example.net',
                      :generate_password => '1'
                    },
                    :continue => '1'
                  }
                  assert_redirected_to '/users/new?user%5Bgenerate_password%5D=1'
                end
                def test_create_with_failure
                  assert_no_difference 'User.count' do
                    post :create, :params => {:user => {}}
                  end
                  assert_response :success
-                 assert_template 'new'
+                 assert_select_error /Email cannot be blank/
                end
                def test_create_with_failure_sould_preserve_preference
                  assert_no_difference 'User.count' do
                    post :create, :params => {
                      :user => {},
                      :pref => {
                        'no_self_notified' => '1',
                        'hide_mail' => '1',
                        'time_zone' => 'Paris',
                        'comments_sorting' => 'desc',
                        'warn_on_leaving_unsaved' => '0'
                      }
                    }
                  end
                  assert_response :success
-                 assert_template 'new'
                  assert_select 'select#pref_time_zone option[selected=selected]', :text => /Paris/
                  assert_select 'input#pref_no_self_notified[value="1"][checked=checked]'
                end
                def test_create_admin_should_send_security_notification
                  ActionMailer::Base.deliveries.clear
                  post :create, :params => {
                    :user => {
                      :firstname => 'Edgar',
                      :lastname => 'Schmoe',
                      :login => 'eschmoe',
                      :password => 'secret123',
                      :password_confirmation => 'secret123',
                      :mail => 'eschmoe@example.foo',
                      :admin => '1'
                    }
                  }
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match '0.0.0.0', mail
                  assert_mail_body_match I18n.t(:mail_body_security_notification_add, field: I18n.t(:field_admin), value: 'eschmoe'), mail
                  assert_select_email do
                    assert_select 'a[href^=?]', 'http://localhost:3000/users', :text => 'Users'
                  end
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                end
                def test_create_non_admin_should_not_send_security_notification
                  ActionMailer::Base.deliveries.clear
                  post :create, :params => {
                    :user => {
                      :firstname => 'Edgar',
                      :lastname => 'Schmoe',
                      :login => 'eschmoe',
                      :password => 'secret123',
                      :password_confirmation => 'secret123',
                      :mail => 'eschmoe@example.foo',
                      :admin => '0'
                    }
                  }
                  assert_nil ActionMailer::Base.deliveries.last
                end
                def test_edit
                  get :edit, :params => {:id => 2}
                  assert_response :success
-                 assert_template 'edit'
-                 assert_equal User.find(2), assigns(:user)
+                 assert_select 'input[name=?][value=?]', 'user[login]', 'jsmith'
                end
                def test_edit_registered_user
                  assert User.find(2).register!
                  get :edit, :params => {:id => 2}
                  assert_response :success
                  assert_select 'a', :text => 'Activate'
                end
                def test_update
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => 2,
                    :user => {:firstname => 'Changed', :mail_notification => 'only_assigned'},
                    :pref => {:hide_mail => '1', :comments_sorting => 'desc'}
                  }
                  user = User.find(2)
                  assert_equal 'Changed', user.firstname
                  assert_equal 'only_assigned', user.mail_notification
                  assert_equal true, user.pref[:hide_mail]
                  assert_equal 'desc', user.pref[:comments_sorting]
                  assert ActionMailer::Base.deliveries.empty?
                end
                def test_update_with_failure
                  assert_no_difference 'User.count' do
                    put :update, :params => {
                      :id => 2,
                      :user => {:firstname => ''}
                    }
                  end
                  assert_response :success
-                 assert_template 'edit'
+                 assert_select_error /First name cannot be blank/
                end
                def test_update_with_group_ids_should_assign_groups
                  put :update, :params => {
                    :id => 2,
                    :user => {:group_ids => ['10']}
                  }
                  user = User.find(2)
                  assert_equal [10], user.group_ids
                end
                def test_update_with_activation_should_send_a_notification
                  u = User.new(:firstname => 'Foo', :lastname => 'Bar', :mail => 'foo.bar@somenet.foo', :language => 'fr')
                  u.login = 'foo'
                  u.status = User::STATUS_REGISTERED
                  u.save!
                  ActionMailer::Base.deliveries.clear
                  Setting.bcc_recipients = '1'
                  put :update, :params => {
                    :id => u.id,
                    :user => {:status => User::STATUS_ACTIVE}
                  }
                  assert u.reload.active?
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  assert_equal ['foo.bar@somenet.foo'], mail.bcc
                  assert_mail_body_match ll('fr', :notice_account_activated), mail
                end
                def test_update_with_password_change_should_send_a_notification
                  ActionMailer::Base.deliveries.clear
                  Setting.bcc_recipients = '1'
                  put :update, :params => {
                    :id => 2,
                    :user => {:password => 'newpass123', :password_confirmation => 'newpass123'},
                    :send_information => '1'
                  }
                  u = User.find(2)
                  assert u.check_password?('newpass123')
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  assert_equal [u.mail], mail.bcc
                  assert_mail_body_match 'newpass123', mail
                end
                def test_update_with_generate_password_should_email_the_password
                  ActionMailer::Base.deliveries.clear
                  Setting.bcc_recipients = '1'
                  put :update, :params => {
                    :id => 2,
                    :user => {
                      :generate_password => '1',
                      :password => '',
                      :password_confirmation => ''
                    },
                    :send_information => '1'
                  }
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  m = mail_body(mail).match(/Password: ([a-zA-Z0-9]+)/)
                  assert m
                  password = m[1]
                  assert User.find(2).check_password?(password)
                end
                def test_update_without_generate_password_should_not_change_password
                  put :update, :params => {
                    :id => 2, :user => {
                      :firstname => 'changed',
                      :generate_password => '0',
                      :password => '',
                      :password_confirmation => ''
                    },
                    :send_information => '1'
                  }
                  user = User.find(2)
                  assert_equal 'changed', user.firstname
                  assert user.check_password?('jsmith')
                end
                def test_update_user_switchin_from_auth_source_to_password_authentication
                  # Configure as auth source
                  u = User.find(2)
                  u.auth_source = AuthSource.find(1)
                  u.save!
                  put :update, :params => {
                    :id => u.id,
                    :user => {:auth_source_id => '', :password => 'newpass123', :password_confirmation => 'newpass123'}
                  }
                  assert_equal nil, u.reload.auth_source
                  assert u.check_password?('newpass123')
                end
                def test_update_notified_project
                  get :edit, :params => {:id => 2}
                  assert_response :success
-                 assert_template 'edit'
                  u = User.find(2)
                  assert_equal [1, 2, 5], u.projects.collect{|p| p.id}.sort
                  assert_equal [1, 2, 5], u.notified_projects_ids.sort
                  assert_select 'input[name=?][value=?]', 'user[notified_project_ids][]', '1'
                  assert_equal 'all', u.mail_notification
                  put :update, :params => {
                    :id => 2,
                    :user => {
                      :mail_notification => 'selected',
                      :notified_project_ids => [1, 2]
                    }
                  }
                  u = User.find(2)
                  assert_equal 'selected', u.mail_notification
                  assert_equal [1, 2], u.notified_projects_ids.sort
                end
                def test_update_status_should_not_update_attributes
                  user = User.find(2)
                  user.pref[:no_self_notified] = '1'
                  user.pref.save
                  put :update, :params => {
                    :id => 2,
                    :user => {:status => 3}
                  }
                  assert_response 302
                  user = User.find(2)
                  assert_equal 3, user.status
                  assert_equal '1', user.pref[:no_self_notified]
                end
                def test_update_assign_admin_should_send_security_notification
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => 2,
                    :user => {:admin => 1}
                  }
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match I18n.t(:mail_body_security_notification_add, field: I18n.t(:field_admin), value: User.find(2).login), mail
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                end
                def test_update_unassign_admin_should_send_security_notification
                  user = User.find(2)
                  user.admin = true
                  user.save!
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => user.id,
                    :user => {:admin => 0}
                  }
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match I18n.t(:mail_body_security_notification_remove, field: I18n.t(:field_admin), value: user.login), mail
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                end
                def test_update_lock_admin_should_send_security_notification
                  user = User.find(2)
                  user.admin = true
                  user.save!
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => 2,
                    :user => {:status => Principal::STATUS_LOCKED}
                  }
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match I18n.t(:mail_body_security_notification_remove, field: I18n.t(:field_admin), value: User.find(2).login), mail
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                  # if user is already locked, destroying should not send a second mail
                  # (for active admins see furtherbelow)
                  ActionMailer::Base.deliveries.clear
                  delete :destroy, :params => {:id => 1}
                  assert_nil ActionMailer::Base.deliveries.last
                end
                def test_update_unlock_admin_should_send_security_notification
                  user = User.find(5) # already locked
                  user.admin = true
                  user.save!
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => user.id,
                    :user => {:status => Principal::STATUS_ACTIVE}
                  }
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match I18n.t(:mail_body_security_notification_add, field: I18n.t(:field_admin), value: user.login), mail
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                end
                def test_update_admin_unrelated_property_should_not_send_security_notification
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => 1,
                    :user => {:firstname => 'Jimmy'}
                  }
                  assert_nil ActionMailer::Base.deliveries.last
                end
                def test_destroy
                  assert_difference 'User.count', -1 do
                    delete :destroy, :params => {:id => 2}
                  end
                  assert_redirected_to '/users'
                  assert_nil User.find_by_id(2)
                end
                def test_destroy_should_be_denied_for_non_admin_users
                  @request.session[:user_id] = 3
                  assert_no_difference 'User.count' do
                    get :destroy, :params => {:id => 2}
                  end
                  assert_response 403
                end
                def test_destroy_should_redirect_to_back_url_param
                  assert_difference 'User.count', -1 do
                    delete :destroy, :params => {:id => 2, :back_url => '/users?name=foo'}
                  end
                  assert_redirected_to '/users?name=foo'
                end
                def test_destroy_active_admin_should_send_security_notification
                  user = User.find(2)
                  user.admin = true
                  user.save!
                  ActionMailer::Base.deliveries.clear
                  delete :destroy, :params => {:id => user.id}
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match I18n.t(:mail_body_security_notification_remove, field: I18n.t(:field_admin), value: user.login), mail
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                end
              end

test/functional/versions_controller_test.rb +20 -27

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

test/functional/watchers_controller_test.rb +4 -6

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

test/functional/welcome_controller_test.rb +7 -8

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../test_helper', __FILE__)
              class WelcomeControllerTest < Redmine::ControllerTest
                fixtures :projects, :news, :users, :members
                def setup
                  Setting.default_language = 'en'
                  User.current = nil
                end
                def test_index
                  get :index
                  assert_response :success
-                 assert_template 'index'
-                 assert_not_nil assigns(:news)
+                 assert_select 'h3', :text => 'Latest news'
                end
                def test_browser_language
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  get :index
-                 assert_equal :fr, @controller.current_language
+                 assert_select 'html[lang=fr]'
                end
                def test_browser_language_alternate
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'zh-TW'
                  get :index
-                 assert_equal :"zh-TW", @controller.current_language
+                 assert_select 'html[lang=zh-TW]'
                end
                def test_browser_language_alternate_not_valid
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr-CA'
                  get :index
-                 assert_equal :fr, @controller.current_language
+                 assert_select 'html[lang=fr]'
                end
                def test_browser_language_should_be_ignored_with_force_default_language_for_anonymous
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  with_settings :force_default_language_for_anonymous => '1' do
                    get :index
-                   assert_equal :en, @controller.current_language
+                   assert_select 'html[lang=en]'
                  end
                end
                def test_user_language_should_be_used
                  user = User.find(2).update_attribute :language, 'it'
                  @request.session[:user_id] = 2
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  with_settings :default_language => 'fi' do
                    get :index
-                   assert_equal :it, @controller.current_language
+                   assert_select 'html[lang=it]'
                  end
                end
                def test_user_language_should_be_ignored_if_force_default_language_for_loggedin
                  user = User.find(2).update_attribute :language, 'it'
                  @request.session[:user_id] = 2
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  with_settings :force_default_language_for_loggedin => '1', :default_language => 'fi' do
                    get :index
-                   assert_equal :fi, @controller.current_language
+                   assert_select 'html[lang=fi]'
                  end
                end
                def test_robots
                  get :robots
                  assert_response :success
                  assert_equal 'text/plain', @response.content_type
                  assert @response.body.match(%r{^Disallow: /projects/ecookbook/issues\r?$})
                end
                def test_warn_on_leaving_unsaved_turn_on
                  user = User.find(2)
                  user.pref.warn_on_leaving_unsaved = '1'
                  user.pref.save!
                  @request.session[:user_id] = 2
                  get :index
                  assert_select 'script', :text => %r{warnLeavingUnsaved}
                end
                def test_warn_on_leaving_unsaved_turn_off
                  user = User.find(2)
                  user.pref.warn_on_leaving_unsaved = '0'
                  user.pref.save!
                  @request.session[:user_id] = 2
                  get :index
                  assert_select 'script', :text => %r{warnLeavingUnsaved}, :count => 0
                end
                def test_logout_link_should_post
                  @request.session[:user_id] = 2
                  get :index
                  assert_select 'a[href="/logout"][data-method=post]', :text => 'Sign out'
                end
                def test_call_hook_mixed_in
                  assert @controller.respond_to?(:call_hook)
                end
                def test_project_jump_box_should_escape_names_once
                  Project.find(1).update_attribute :name, 'Foo & Bar'
                  @request.session[:user_id] = 2
                  get :index
                  assert_select "#header select" do
                    assert_select "option", :text => 'Foo & Bar'
                  end
                end
                def test_api_offset_and_limit_without_params
                  assert_equal [0, 25], @controller.api_offset_and_limit({})
                end
                def test_api_offset_and_limit_with_limit
                  assert_equal [0, 30], @controller.api_offset_and_limit({:limit => 30})
                  assert_equal [0, 100], @controller.api_offset_and_limit({:limit => 120})
                  assert_equal [0, 25], @controller.api_offset_and_limit({:limit => -10})
                end
                def test_api_offset_and_limit_with_offset
                  assert_equal [10, 25], @controller.api_offset_and_limit({:offset => 10})
                  assert_equal [0, 25], @controller.api_offset_and_limit({:offset => -10})
                end
                def test_api_offset_and_limit_with_offset_and_limit
                  assert_equal [10, 50], @controller.api_offset_and_limit({:offset => 10, :limit => 50})
                end
                def test_api_offset_and_limit_with_page
                  assert_equal [0, 25], @controller.api_offset_and_limit({:page => 1})
                  assert_equal [50, 25], @controller.api_offset_and_limit({:page => 3})
                  assert_equal [0, 25], @controller.api_offset_and_limit({:page => 0})
                  assert_equal [0, 25], @controller.api_offset_and_limit({:page => -2})
                end
                def test_api_offset_and_limit_with_page_and_limit
                  assert_equal [0, 100], @controller.api_offset_and_limit({:page => 1, :limit => 100})
                  assert_equal [200, 100], @controller.api_offset_and_limit({:page => 3, :limit => 100})
                end
                def test_unhautorized_exception_with_anonymous_should_redirect_to_login
                  WelcomeController.any_instance.stubs(:index).raises(::Unauthorized)
                  get :index
                  assert_response 302
                  assert_redirected_to('/login?back_url='+CGI.escape('http://test.host/'))
                end
                def test_unhautorized_exception_with_anonymous_and_xmlhttprequest_should_respond_with_401_to_anonymous
                  WelcomeController.any_instance.stubs(:index).raises(::Unauthorized)
                  @request.env["HTTP_X_REQUESTED_WITH"] = "XMLHttpRequest"
                  get :index
                  assert_response 401
                end
              end

test/functional/wiki_controller_test.rb +36 -59

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

test/functional/wikis_controller_test.rb 0 -3

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

test/functional/workflows_controller_test.rb +19 -17

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

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