jro_apps/redmine Commit - r15333:bb5ccb870ce3

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

Jean-Philippe Lang -

r15333:bb5ccb870ce3

parent child

Context file:

r15333:bb5ccb870ce3

Collapse all files

app/controllers/reports_controller.rb +2 -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.
             class ReportsController < ApplicationController
               menu_item :issues
               before_action :find_project, :authorize, :find_issue_statuses
               def issue_report
                 @trackers = @project.rolled_up_trackers(false).visible
                 @versions = @project.shared_versions.sort
                 @priorities = IssuePriority.all.reverse
                 @categories = @project.issue_categories
                 @assignees = (Setting.issue_group_assignment? ? @project.principals : @project.users).sort
                 @authors = @project.users.sort
                 @subprojects = @project.descendants.visible
                 @issues_by_tracker = Issue.by_tracker(@project)
                 @issues_by_version = Issue.by_version(@project)
                 @issues_by_priority = Issue.by_priority(@project)
                 @issues_by_category = Issue.by_category(@project)
                 @issues_by_assigned_to = Issue.by_assigned_to(@project)
                 @issues_by_author = Issue.by_author(@project)
                 @issues_by_subproject = Issue.by_subproject(@project) || []
                 render :template => "reports/issue_report"
               end
               def issue_report_details
                 case params[:detail]
                 when "tracker"
                   @field = "tracker_id"
                   @rows = @project.rolled_up_trackers(false).visible
                   @data = Issue.by_tracker(@project)
                   @report_title = l(:field_tracker)
                 when "version"
                   @field = "fixed_version_id"
                   @rows = @project.shared_versions.sort
                   @data = Issue.by_version(@project)
                   @report_title = l(:field_version)
                 when "priority"
                   @field = "priority_id"
                   @rows = IssuePriority.all.reverse
                   @data = Issue.by_priority(@project)
                   @report_title = l(:field_priority)
                 when "category"
                   @field = "category_id"
                   @rows = @project.issue_categories
                   @data = Issue.by_category(@project)
                   @report_title = l(:field_category)
                 when "assigned_to"
                   @field = "assigned_to_id"
                   @rows = (Setting.issue_group_assignment? ? @project.principals : @project.users).sort
                   @data = Issue.by_assigned_to(@project)
                   @report_title = l(:field_assigned_to)
                 when "author"
                   @field = "author_id"
                   @rows = @project.users.sort
                   @data = Issue.by_author(@project)
                   @report_title = l(:field_author)
                 when "subproject"
                   @field = "project_id"
                   @rows = @project.descendants.visible
                   @data = Issue.by_subproject(@project) || []
                   @report_title = l(:field_subproject)
-                end
+                else
+                  render_404
-                respond_to do |format|
-                  if @field
-                    format.html {}
-                  else
-                    format.html { redirect_to :action => 'issue_report', :id => @project }
-                  end
                 end
               end
               private
               def find_issue_statuses
                 @statuses = IssueStatus.sorted.to_a
               end
             end

test/functional/messages_controller_test.rb +16 -16

             # 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 MessagesControllerTest < Redmine::ControllerTest
               fixtures :projects, :users, :email_addresses, :user_preferences, :members, :member_roles, :roles, :boards, :messages, :enabled_modules
               def setup
                 User.current = nil
               end
               def test_show
                 get :show, :board_id => 1, :id => 1
                 assert_response :success
-                assert_template 'show'
-                assert_not_nil assigns(:board)
+                assert_select 'h2', :text => 'First post'
-                assert_not_nil assigns(:project)
-                assert_not_nil assigns(:topic)
               end
               def test_show_should_contain_reply_field_tags_for_quoting
                 @request.session[:user_id] = 2
                 get :show, :board_id => 1, :id => 1
                 assert_response :success
                 # tags required by MessagesController#quote
                 assert_select 'input#message_subject'
                 assert_select 'textarea#message_content'
                 assert_select 'div#reply'
               end
               def test_show_with_pagination
                 message = Message.find(1)
                 assert_difference 'Message.count', 30 do
 .times do
                     message.children << Message.new(:subject => 'Reply',
                                                     :content => 'Reply body',
                                                     :author_id => 2,
                                                     :board_id => 1)
                   end
                 end
-                get :show, :board_id => 1, :id => 1, :r => message.children.order('id').last.id
+                reply_ids = message.children.map(&:id).sort
+                get :show, :board_id => 1, :id => 1, :r => reply_ids.last
                 assert_response :success
-                assert_template 'show'
-                replies = assigns(:replies)
+                assert_select 'a[href=?]', "/boards/1/topics/1?r=#{reply_ids.last}#message-#{reply_ids.last}"
-                assert_not_nil replies
+                assert_select 'a[href=?]', "/boards/1/topics/1?r=#{reply_ids.first}#message-#{reply_ids.first}", 0
-                assert_not_include message.children.reorder('id').first, replies
-                assert_include message.children.reorder('id').last, replies
               end
               def test_show_with_reply_permission
                 @request.session[:user_id] = 2
                 get :show, :board_id => 1, :id => 1
                 assert_response :success
-                assert_template 'show'
                 assert_select 'div#reply textarea#message_content'
               end
               def test_show_message_not_found
                 get :show, :board_id => 1, :id => 99999
                 assert_response 404
               end
               def test_show_message_from_invalid_board_should_respond_with_404
                 get :show, :board_id => 999, :id => 1
                 assert_response 404
               end
               def test_get_new
                 @request.session[:user_id] = 2
                 get :new, :board_id => 1
                 assert_response :success
-                assert_template 'new'
+                assert_select 'input[name=?]', 'message[subject]'
               end
               def test_get_new_with_invalid_board
                 @request.session[:user_id] = 2
                 get :new, :board_id => 99
                 assert_response 404
               end
               def test_post_new
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 with_settings :notified_events => %w(message_posted) do
                   post :new, :board_id => 1,
                            :message => { :subject => 'Test created message',
                                          :content => 'Message body'}
                 end
                 message = Message.find_by_subject('Test created message')
                 assert_not_nil message
                 assert_redirected_to "/boards/1/topics/#{message.to_param}"
                 assert_equal 'Message body', message.content
                 assert_equal 2, message.author_id
                 assert_equal 1, message.board_id
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert_equal "[#{message.board.project.name} - #{message.board.name} - msg#{message.root.id}] Test created message", mail.subject
                 assert_mail_body_match 'Message body', mail
                 # author
                 assert mail.bcc.include?('jsmith@somenet.foo')
                 # project member
                 assert mail.bcc.include?('dlopper@somenet.foo')
               end
               def test_get_edit
                 @request.session[:user_id] = 2
                 get :edit, :board_id => 1, :id => 1
                 assert_response :success
-                assert_template 'edit'
+                assert_select 'input[name=?][value=?]', 'message[subject]', 'First post'
               end
               def test_post_edit
                 @request.session[:user_id] = 2
                 post :edit, :board_id => 1, :id => 1,
                             :message => { :subject => 'New subject',
                                           :content => 'New body'}
                 assert_redirected_to '/boards/1/topics/1'
                 message = Message.find(1)
                 assert_equal 'New subject', message.subject
                 assert_equal 'New body', message.content
               end
               def test_post_edit_sticky_and_locked
                 @request.session[:user_id] = 2
                 post :edit, :board_id => 1, :id => 1,
                             :message => { :subject => 'New subject',
                                           :content => 'New body',
                                           :locked => '1',
                                           :sticky => '1'}
                 assert_redirected_to '/boards/1/topics/1'
                 message = Message.find(1)
                 assert_equal true, message.sticky?
                 assert_equal true, message.locked?
               end
               def test_post_edit_should_allow_to_change_board
                 @request.session[:user_id] = 2
                 post :edit, :board_id => 1, :id => 1,
                             :message => { :subject => 'New subject',
                                           :content => 'New body',
                                           :board_id => 2}
                 assert_redirected_to '/boards/2/topics/1'
                 message = Message.find(1)
                 assert_equal Board.find(2), message.board
               end
               def test_reply
                 @request.session[:user_id] = 2
                 post :reply, :board_id => 1, :id => 1, :reply => { :content => 'This is a test reply', :subject => 'Test reply' }
                 reply = Message.order('id DESC').first
                 assert_redirected_to "/boards/1/topics/1?r=#{reply.id}"
                 assert Message.find_by_subject('Test reply')
               end
               def test_destroy_topic
                 @request.session[:user_id] = 2
                 assert_difference 'Message.count', -3 do
                   post :destroy, :board_id => 1, :id => 1
                 end
                 assert_redirected_to '/projects/ecookbook/boards/1'
                 assert_nil Message.find_by_id(1)
               end
               def test_destroy_reply
                 @request.session[:user_id] = 2
                 assert_difference 'Message.count', -1 do
                   post :destroy, :board_id => 1, :id => 2
                 end
                 assert_redirected_to '/boards/1/topics/1?r=2'
                 assert_nil Message.find_by_id(2)
               end
               def test_quote
                 @request.session[:user_id] = 2
                 xhr :get, :quote, :board_id => 1, :id => 3
                 assert_response :success
                 assert_equal 'text/javascript', response.content_type
-                assert_template 'quote'
                 assert_include 'RE: First post', response.body
                 assert_include '> An other reply', response.body
               end
               def test_preview_new
                 @request.session[:user_id] = 2
                 post :preview,
                   :board_id => 1,
                   :message => {:subject => "", :content => "Previewed text"}
                 assert_response :success
-                assert_template 'common/_preview'
+                assert_include 'Previewed text', response.body
               end
               def test_preview_edit
                 @request.session[:user_id] = 2
                 post :preview,
                   :id => 4,
                   :board_id => 1,
                   :message => {:subject => "", :content => "Previewed text"}
                 assert_response :success
-                assert_template 'common/_preview'
+                assert_include 'Previewed text', response.body
               end
             end

test/functional/my_controller_test.rb +20 -24

             # 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 MyControllerTest < Redmine::ControllerTest
               fixtures :users, :email_addresses, :user_preferences, :roles, :projects, :members, :member_roles,
               :issues, :issue_statuses, :trackers, :enumerations, :custom_fields, :auth_sources
               def setup
                 @request.session[:user_id] = 2
               end
               def test_index
                 get :index
                 assert_response :success
-                assert_template 'page'
+                assert_select 'h2', 'My page'
               end
               def test_page
                 get :page
                 assert_response :success
-                assert_template 'page'
+                assert_select 'h2', 'My page'
               end
               def test_page_with_timelog_block
                 preferences = User.find(2).pref
                 preferences[:my_page_layout] = {'top' => ['timelog']}
                 preferences.save!
                 TimeEntry.create!(:user => User.find(2), :spent_on => Date.yesterday, :issue_id => 1, :hours => 2.5, :activity_id => 10)
                 get :page
                 assert_response :success
                 assert_select 'tr.time-entry' do
                   assert_select 'td.subject a[href="/issues/1"]'
                   assert_select 'td.hours', :text => '2.50'
                 end
               end
               def test_page_with_all_blocks
                 blocks = MyController::BLOCKS.keys
                 preferences = User.find(2).pref
                 preferences[:my_page_layout] = {'top' => blocks}
                 preferences.save!
                 get :page
                 assert_response :success
                 assert_select 'div.mypage-box', blocks.size
               end
               def test_my_account_should_show_editable_custom_fields
                 get :account
                 assert_response :success
-                assert_template 'account'
-                assert_equal User.find(2), assigns(:user)
                 assert_select 'input[name=?]', 'user[custom_field_values][4]'
               end
               def test_my_account_should_not_show_non_editable_custom_fields
                 UserCustomField.find(4).update_attribute :editable, false
                 get :account
                 assert_response :success
-                assert_template 'account'
-                assert_equal User.find(2), assigns(:user)
                 assert_select 'input[name=?]', 'user[custom_field_values][4]', 0
               end
               def test_my_account_should_show_language_select
                 get :account
                 assert_response :success
                 assert_select 'select[name=?]', 'user[language]'
               end
               def test_my_account_should_not_show_language_select_with_force_default_language_for_loggedin
                 with_settings :force_default_language_for_loggedin => '1' do
                   get :account
                   assert_response :success
                   assert_select 'select[name=?]', 'user[language]', 0
                 end
               end
               def test_update_account
                 post :account,
                   :user => {
                     :firstname => "Joe",
                     :login => "root",
                     :admin => 1,
                     :group_ids => ['10'],
                     :custom_field_values => {"4" => "0100562500"}
                   }
                 assert_redirected_to '/my/account'
                 user = User.find(2)
-                assert_equal user, assigns(:user)
                 assert_equal "Joe", user.firstname
                 assert_equal "jsmith", user.login
                 assert_equal "0100562500", user.custom_value_for(4).value
                 # ignored
                 assert !user.admin?
                 assert user.groups.empty?
               end
               def test_update_account_should_send_security_notification
                 ActionMailer::Base.deliveries.clear
                 post :account,
                   :user => {
                     :mail => 'foobar@example.com'
                   }
                 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_change_to, field: I18n.t(:field_mail), value: 'foobar@example.com'), mail
                 assert_select_email do
                   assert_select 'a[href^=?]', 'http://localhost:3000/my/account', :text => 'My account'
                 end
                 # The old email address should be notified about the change for security purposes
                 assert [mail.bcc, mail.cc].flatten.include?(User.find(2).mail)
                 assert [mail.bcc, mail.cc].flatten.include?('foobar@example.com')
               end
               def test_my_account_should_show_destroy_link
                 get :account
                 assert_select 'a[href="/my/account/destroy"]'
               end
               def test_get_destroy_should_display_the_destroy_confirmation
                 get :destroy
                 assert_response :success
-                assert_template 'destroy'
                 assert_select 'form[action="/my/account/destroy"]' do
                   assert_select 'input[name=confirm]'
                 end
               end
               def test_post_destroy_without_confirmation_should_not_destroy_account
                 assert_no_difference 'User.count' do
                   post :destroy
                 end
                 assert_response :success
-                assert_template 'destroy'
               end
               def test_post_destroy_without_confirmation_should_destroy_account
                 assert_difference 'User.count', -1 do
                   post :destroy, :confirm => '1'
                 end
                 assert_redirected_to '/'
                 assert_match /deleted/i, flash[:notice]
               end
               def test_post_destroy_with_unsubscribe_not_allowed_should_not_destroy_account
                 User.any_instance.stubs(:own_account_deletable?).returns(false)
                 assert_no_difference 'User.count' do
                   post :destroy, :confirm => '1'
                 end
                 assert_redirected_to '/my/account'
               end
               def test_change_password
                 get :password
                 assert_response :success
-                assert_template 'password'
+                assert_select 'input[type=password][name=password]'
+                assert_select 'input[type=password][name=new_password]'
+                assert_select 'input[type=password][name=new_password_confirmation]'
+              end
-                # non matching password confirmation
+              def test_update_password
+                post :password, :password => 'jsmith',
+                                :new_password => 'secret123',
+                                :new_password_confirmation => 'secret123'
+                assert_redirected_to '/my/account'
+                assert User.try_to_login('jsmith', 'secret123')
+              end
+              def test_update_password_with_non_matching_confirmation
                 post :password, :password => 'jsmith',
                                 :new_password => 'secret123',
                                 :new_password_confirmation => 'secret1234'
                 assert_response :success
-                assert_template 'password'
                 assert_select_error /Password doesn.*t match confirmation/
+                assert User.try_to_login('jsmith', 'jsmith')
+              end
+              def test_update_password_with_wrong_password
                 # wrong password
                 post :password, :password => 'wrongpassword',
                                 :new_password => 'secret123',
                                 :new_password_confirmation => 'secret123'
                 assert_response :success
-                assert_template 'password'
                 assert_equal 'Wrong password', flash[:error]
+                assert User.try_to_login('jsmith', 'jsmith')
-                # good password
-                post :password, :password => 'jsmith',
-                                :new_password => 'secret123',
-                                :new_password_confirmation => 'secret123'
-                assert_redirected_to '/my/account'
-                assert User.try_to_login('jsmith', 'secret123')
               end
               def test_change_password_should_redirect_if_user_cannot_change_its_password
                 User.find(2).update_attribute(:auth_source_id, 1)
                 get :password
                 assert_not_nil flash[:error]
                 assert_redirected_to '/my/account'
               end
-              def test_change_password_should_send_security_notification
+              def test_update_password_should_send_security_notification
                 ActionMailer::Base.deliveries.clear
                 post :password, :password => 'jsmith',
                                 :new_password => 'secret123',
                                 :new_password_confirmation => 'secret123'
                 assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                 assert_mail_body_no_match 'secret123', mail # just to be sure: pw should never be sent!
                 assert_select_email do
                   assert_select 'a[href^=?]', 'http://localhost:3000/my/password', :text => 'Change password'
                 end
               end
               def test_page_layout
                 get :page_layout
                 assert_response :success
-                assert_template 'page_layout'
               end
               def test_add_block
                 post :add_block, :block => 'issuesreportedbyme'
                 assert_redirected_to '/my/page_layout'
                 assert User.find(2).pref[:my_page_layout]['top'].include?('issuesreportedbyme')
               end
               def test_add_invalid_block_should_redirect
                 post :add_block, :block => 'invalid'
                 assert_redirected_to '/my/page_layout'
               end
               def test_remove_block
                 post :remove_block, :block => 'issuesassignedtome'
                 assert_redirected_to '/my/page_layout'
                 assert !User.find(2).pref[:my_page_layout].values.flatten.include?('issuesassignedtome')
               end
               def test_order_blocks
                 xhr :post, :order_blocks, :group => 'left', 'blocks' => ['documents', 'calendar', 'latestnews']
                 assert_response :success
                 assert_equal ['documents', 'calendar', 'latestnews'], User.find(2).pref[:my_page_layout]['left']
               end
               def test_reset_rss_key_with_existing_key
                 @previous_token_value = User.find(2).rss_key # Will generate one if it's missing
                 post :reset_rss_key
                 assert_not_equal @previous_token_value, User.find(2).rss_key
                 assert User.find(2).rss_token
                 assert_match /reset/, flash[:notice]
                 assert_redirected_to '/my/account'
               end
               def test_reset_rss_key_without_existing_key
                 assert_nil User.find(2).rss_token
                 post :reset_rss_key
                 assert User.find(2).rss_token
                 assert_match /reset/, flash[:notice]
                 assert_redirected_to '/my/account'
               end
               def test_show_api_key
                 get :show_api_key
                 assert_response :success
                 assert_select 'pre', User.find(2).api_key
               end
               def test_reset_api_key_with_existing_key
                 @previous_token_value = User.find(2).api_key # Will generate one if it's missing
                 post :reset_api_key
                 assert_not_equal @previous_token_value, User.find(2).api_key
                 assert User.find(2).api_token
                 assert_match /reset/, flash[:notice]
                 assert_redirected_to '/my/account'
               end
               def test_reset_api_key_without_existing_key
                 assert_nil User.find(2).api_token
                 post :reset_api_key
                 assert User.find(2).api_token
                 assert_match /reset/, flash[:notice]
                 assert_redirected_to '/my/account'
               end
             end

test/functional/news_controller_test.rb +8 -14

             # 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 NewsControllerTest < Redmine::ControllerTest
               fixtures :projects, :users, :email_addresses, :roles, :members, :member_roles,
                        :enabled_modules, :news, :comments,
                        :attachments
               def setup
                 User.current = nil
               end
               def test_index
                 get :index
                 assert_response :success
-                assert_template 'index'
+                assert_select 'h3 a', :text => 'eCookbook first release !'
-                assert_not_nil assigns(:newss)
-                assert_nil assigns(:project)
               end
               def test_index_with_project
                 get :index, :project_id => 1
                 assert_response :success
-                assert_template 'index'
+                assert_select 'h3 a', :text => 'eCookbook first release !'
-                assert_not_nil assigns(:newss)
               end
               def test_index_with_invalid_project_should_respond_with_404
                 get :index, :project_id => 999
                 assert_response 404
               end
               def test_show
                 get :show, :id => 1
                 assert_response :success
-                assert_template 'show'
+                assert_select 'h2', :text => 'eCookbook first release !'
-                assert_select 'h2', :text => /eCookbook first release/
               end
               def test_show_should_show_attachments
                 attachment = Attachment.first
                 attachment.container = News.find(1)
                 attachment.save!
                 get :show, :id => 1
                 assert_response :success
                 assert_select 'a', :text => attachment.filename
               end
               def test_show_with_comments_in_reverse_order
                 user = User.find(1)
                 user.pref[:comments_sorting] = 'desc'
                 user.pref.save!
                 @request.session[:user_id] = 1
                 get :show, :id => 1
                 assert_response :success
-                assert_equal News.find(1).comments.to_a.sort_by(&:created_on).reverse, assigns(:comments)
+                comments = css_select('#comments .wiki').map(&:text).map(&:strip)
+                assert_equal ["This is an other comment", "my first comment"], comments
               end
               def test_show_not_found
                 get :show, :id => 999
                 assert_response 404
               end
               def test_get_new
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1
                 assert_response :success
-                assert_template 'new'
+                assert_select 'input[name=?]', 'news[title]'
               end
               def test_post_create
                 ActionMailer::Base.deliveries.clear
                 @request.session[:user_id] = 2
                 with_settings :notified_events => %w(news_added) do
                   post :create, :project_id => 1, :news => { :title => 'NewsControllerTest',
                                                         :description => 'This is the description',
                                                         :summary => '' }
                 end
                 assert_redirected_to '/projects/ecookbook/news'
                 news = News.find_by_title('NewsControllerTest')
                 assert_not_nil news
                 assert_equal 'This is the description', news.description
                 assert_equal User.find(2), news.author
                 assert_equal Project.find(1), news.project
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_post_create_with_attachment
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 assert_difference 'News.count' do
                   assert_difference 'Attachment.count' do
                     post :create, :project_id => 1,
                       :news => { :title => 'Test', :description => 'This is the description' },
                       :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                   end
                 end
                 attachment = Attachment.order('id DESC').first
                 news = News.order('id DESC').first
                 assert_equal news, attachment.container
               end
               def test_post_create_with_validation_failure
                 @request.session[:user_id] = 2
                 post :create, :project_id => 1, :news => { :title => '',
                                                         :description => 'This is the description',
                                                         :summary => '' }
                 assert_response :success
-                assert_template 'new'
-                assert_not_nil assigns(:news)
-                assert assigns(:news).new_record?
                 assert_select_error /title cannot be blank/i
               end
               def test_get_edit
                 @request.session[:user_id] = 2
                 get :edit, :id => 1
                 assert_response :success
-                assert_template 'edit'
+                assert_select 'input[name=?][value=?]', 'news[title]', 'eCookbook first release !'
               end
               def test_put_update
                 @request.session[:user_id] = 2
                 put :update, :id => 1, :news => { :description => 'Description changed by test_post_edit' }
                 assert_redirected_to '/news/1'
                 news = News.find(1)
                 assert_equal 'Description changed by test_post_edit', news.description
               end
               def test_put_update_with_attachment
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 assert_no_difference 'News.count' do
                   assert_difference 'Attachment.count' do
                     put :update, :id => 1,
                       :news => { :description => 'This is the description' },
                       :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                   end
                 end
                 attachment = Attachment.order('id DESC').first
                 assert_equal News.find(1), attachment.container
               end
               def test_update_with_failure
                 @request.session[:user_id] = 2
                 put :update, :id => 1, :news => { :description => '' }
                 assert_response :success
-                assert_template 'edit'
                 assert_select_error /description cannot be blank/i
               end
               def test_destroy
                 @request.session[:user_id] = 2
                 delete :destroy, :id => 1
                 assert_redirected_to '/projects/ecookbook/news'
                 assert_nil News.find_by_id(1)
               end
             end

test/functional/previews_controller_test.rb +19 -15

             # 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 PreviewsControllerTest < Redmine::ControllerTest
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :journals, :journal_details,
                        :news
               def test_preview_new_issue
                 @request.session[:user_id] = 2
                 post :issue, :project_id => '1', :issue => {:description => 'Foo'}
                 assert_response :success
-                assert_template 'previews/issue'
+                assert_select 'fieldset' do
-                assert_not_nil assigns(:description)
+                  assert_select 'legend', :text => 'Description'
+                  assert_select 'p', :text => 'Foo'
+                end
               end
-              def test_preview_issue_notes
+              def test_preview_issue_notes_with_no_change_to_description
                 @request.session[:user_id] = 2
                 post :issue, :project_id => '1', :id => 1,
                      :issue => {:description => Issue.find(1).description, :notes => 'Foo'}
                 assert_response :success
-                assert_template 'previews/issue'
+                assert_select 'legend', :text => 'Description', :count => 0
-                assert_not_nil assigns(:notes)
+                assert_select 'legend', :text => 'Notes'
+              end
+              def test_preview_issue_notes_with_no_change_to_description
+                @request.session[:user_id] = 2
+                post :issue, :project_id => '1', :id => 1,
+                     :issue => {:description => 'Changed description', :notes => 'Foo'}
+                assert_response :success
+                assert_select 'legend', :text => 'Description'
+                assert_select 'legend', :text => 'Notes'
               end
               def test_preview_journal_notes_for_update
                 @request.session[:user_id] = 2
                 post :issue, :project_id => '1', :id => 1, :notes => 'Foo'
                 assert_response :success
-                assert_template 'previews/issue'
+                assert_select 'legend', :text => 'Notes'
-                assert_not_nil assigns(:notes)
                 assert_select 'p', :text => 'Foo'
               end
               def test_preview_issue_notes_should_support_links_to_existing_attachments
                 Attachment.generate!(:container => Issue.find(1), :filename => 'foo.bar')
                 @request.session[:user_id] = 2
                 post :issue, :project_id => '1', :id => 1, :notes => 'attachment:foo.bar'
                 assert_response :success
                 assert_select 'a.attachment', :text => 'foo.bar'
               end
               def test_preview_issue_with_project_changed
                 @request.session[:user_id] = 2
                 post :issue, :project_id => '1', :id => 1, :issue => {:notes => 'notes', :project_id => 2}
                 assert_response :success
-                assert_not_nil assigns(:issue)
+                assert_select 'legend', :text => 'Notes'
-                assert_not_nil assigns(:notes)
               end
               def test_preview_new_news
                 get :news, :project_id => 1,
                               :news => {:title => '',
                                         :description => 'News description',
                                         :summary => ''}
                 assert_response :success
-                assert_template 'common/_preview'
                 assert_select 'fieldset.preview', :text => /News description/
               end
-              def test_existing_new_news
+              def test_preview_existing_news
                 get :news, :project_id => 1, :id => 2,
                               :news => {:title => '',
                                         :description => 'News description',
                                         :summary => ''}
                 assert_response :success
-                assert_template 'common/_preview'
-                assert_equal News.find(2), assigns(:previewed)
-                assert_not_nil assigns(:attachments)
                 assert_select 'fieldset.preview', :text => /News description/
               end
             end

test/functional/principal_memberships_controller_test.rb 0 -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 PrincipalMembershipsControllerTest < Redmine::ControllerTest
               fixtures :projects, :users, :members, :member_roles, :roles, :groups_users
               def setup
                 @request.session[:user_id] = 1
               end
               def test_new_user_membership
                 get :new, :user_id => 7
                 assert_response :success
                 assert_select 'label', :text => 'eCookbook' do
                   assert_select 'input[name=?][value="1"]:not([disabled])', 'membership[project_ids][]'
                 end
               end
               def test_new_user_membership_should_disable_user_projects
                 Member.create!(:user_id => 7, :project_id => 1, :role_ids => [1])
                 get :new, :user_id => 7
                 assert_response :success
                 assert_select 'label', :text => 'eCookbook' do
                   assert_select 'input[name=?][value="1"][disabled=disabled]', 'membership[project_ids][]'
                 end
               end
               def test_xhr_new_user_membership
                 xhr :get, :new, :user_id => 7
                 assert_response :success
                 assert_equal 'text/javascript', response.content_type
               end
               def test_create_user_membership
                 assert_difference 'Member.count' do
                   post :create, :user_id => 7, :membership => {:project_ids => [3], :role_ids => [2]}
                 end
                 assert_redirected_to '/users/7/edit?tab=memberships'
                 member = Member.order('id DESC').first
                 assert_equal User.find(7), member.principal
                 assert_equal [2], member.role_ids
                 assert_equal 3, member.project_id
               end
               def test_create_user_membership_with_multiple_roles
                 assert_difference 'Member.count' do
                   post :create, :user_id => 7, :membership => {:project_ids => [3], :role_ids => [2, 3]}
                 end
                 member = Member.order('id DESC').first
                 assert_equal User.find(7), member.principal
                 assert_equal [2, 3], member.role_ids.sort
                 assert_equal 3, member.project_id
               end
               def test_create_user_membership_with_multiple_projects_and_roles
                 assert_difference 'Member.count', 2 do
                   post :create, :user_id => 7, :membership => {:project_ids => [1, 3], :role_ids => [2, 3]}
                 end
                 members = Member.order('id DESC').limit(2).sort_by(&:project_id)
                 assert_equal 1, members[0].project_id
                 assert_equal 3, members[1].project_id
                 members.each do |member|
                   assert_equal User.find(7), member.principal
                   assert_equal [2, 3], member.role_ids.sort
                 end
               end
               def test_xhr_create_user_membership
                 assert_difference 'Member.count' do
                   xhr :post, :create, :user_id => 7, :membership => {:project_ids => [3], :role_ids => [2]}, :format => 'js'
                   assert_response :success
-                  assert_template 'create'
                   assert_equal 'text/javascript', response.content_type
                 end
                 member = Member.order('id DESC').first
                 assert_equal User.find(7), member.principal
                 assert_equal [2], member.role_ids
                 assert_equal 3, member.project_id
                 assert_include 'tab-content-memberships', response.body
               end
               def test_xhr_create_user_membership_with_failure
                 assert_no_difference 'Member.count' do
                   xhr :post, :create, :user_id => 7, :membership => {:project_ids => [3]}, :format => 'js'
                   assert_response :success
-                  assert_template 'create'
                   assert_equal 'text/javascript', response.content_type
                 end
                 assert_include 'alert', response.body, "Alert message not sent"
                 assert_include 'Role cannot be empty', response.body, "Error message not sent"
               end
               def test_update_user_membership
                 assert_no_difference 'Member.count' do
                   put :update, :user_id => 2, :id => 1, :membership => {:role_ids => [2]}
                   assert_redirected_to '/users/2/edit?tab=memberships'
                 end
                 assert_equal [2], Member.find(1).role_ids
               end
               def test_xhr_update_user_membership
                 assert_no_difference 'Member.count' do
                   xhr :put, :update, :user_id => 2, :id => 1, :membership => {:role_ids => [2]}, :format => 'js'
                   assert_response :success
-                  assert_template 'update'
                   assert_equal 'text/javascript', response.content_type
                 end
                 assert_equal [2], Member.find(1).role_ids
                 assert_include 'tab-content-memberships', response.body
               end
               def test_destroy_user_membership
                 assert_difference 'Member.count', -1 do
                   delete :destroy, :user_id => 2, :id => 1
                 end
                 assert_redirected_to '/users/2/edit?tab=memberships'
                 assert_nil Member.find_by_id(1)
               end
               def test_xhr_destroy_user_membership_js_format
                 assert_difference 'Member.count', -1 do
                   xhr :delete, :destroy, :user_id => 2, :id => 1
                   assert_response :success
-                  assert_template 'destroy'
                   assert_equal 'text/javascript', response.content_type
                 end
                 assert_nil Member.find_by_id(1)
                 assert_include 'tab-content-memberships', response.body
               end
               def test_xhr_new_group_membership
                 xhr :get, :new, :group_id => 10
                 assert_response :success
                 assert_equal 'text/javascript', response.content_type
               end
               def test_create_group_membership
                 assert_difference 'Group.find(10).members.count' do
                   post :create, :group_id => 10, :membership => {:project_ids => [2], :role_ids => ['1', '2']}
                 end
               end
               def test_xhr_create_group_membership
                 assert_difference 'Group.find(10).members.count' do
                   xhr :post, :create, :group_id => 10, :membership => {:project_ids => [2], :role_ids => ['1', '2']}
                   assert_response :success
-                  assert_template 'create'
                   assert_equal 'text/javascript', response.content_type
                 end
                 assert_match /OnlineStore/, response.body
               end
               def test_xhr_create_group_membership_with_failure
                 assert_no_difference 'Group.find(10).members.count' do
                   xhr :post, :create, :group_id => 10, :membership => {:project_ids => [999], :role_ids => ['1', '2']}
                   assert_response :success
-                  assert_template 'create'
                   assert_equal 'text/javascript', response.content_type
                 end
                 assert_match /alert/, response.body, "Alert message not sent"
               end
               def test_update_group_membership
                 assert_no_difference 'Group.find(10).members.count' do
                   put :update, :group_id => 10, :id => 6, :membership => {:role_ids => ['1', '3']}
                 end
               end
               def test_xhr_update_group_membership
                 assert_no_difference 'Group.find(10).members.count' do
                   xhr :post, :update, :group_id => 10, :id => 6, :membership => {:role_ids => ['1', '3']}
                   assert_response :success
-                  assert_template 'update'
                   assert_equal 'text/javascript', response.content_type
                 end
               end
               def test_destroy_group_membership
                 assert_difference 'Group.find(10).members.count', -1 do
                   delete :destroy, :group_id => 10, :id => 6
                 end
               end
               def test_xhr_destroy_group_membership
                 assert_difference 'Group.find(10).members.count', -1 do
                   xhr :delete, :destroy, :group_id => 10, :id => 6
                   assert_response :success
-                  assert_template 'destroy'
                   assert_equal 'text/javascript', response.content_type
                 end
               end
             end

test/functional/projects_controller_test.rb +32 -51

             # 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 ProjectsControllerTest < Redmine::ControllerTest
               fixtures :projects, :versions, :users, :email_addresses, :roles, :members,
                        :member_roles, :issues, :journals, :journal_details,
                        :trackers, :projects_trackers, :issue_statuses,
                        :enabled_modules, :enumerations, :boards, :messages,
                        :attachments, :custom_fields, :custom_values, :time_entries,
                        :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions
               def setup
                 @request.session[:user_id] = nil
                 Setting.default_language = 'en'
               end
               def test_index_by_anonymous_should_not_show_private_projects
                 get :index
                 assert_response :success
-                assert_template 'index'
-                projects = assigns(:projects)
-                assert_not_nil projects
-                assert projects.all?(&:is_public?)
                 assert_select 'ul' do
                   assert_select 'li' do
                     assert_select 'a', :text => 'eCookbook'
                     assert_select 'ul' do
                       assert_select 'a', :text => 'Child of private child'
                     end
                   end
                 end
                 assert_select 'a', :text => /Private child of eCookbook/, :count => 0
               end
               def test_index_atom
                 get :index, :format => 'atom'
                 assert_response :success
-                assert_template 'common/feed'
                 assert_select 'feed>title', :text => 'Redmine: Latest projects'
                 assert_select 'feed>entry', :count => Project.visible(User.current).count
               end
               test "#index by non-admin user with view_time_entries permission should show overall spent time link" do
                 @request.session[:user_id] = 3
                 get :index
-                assert_template 'index'
                 assert_select 'a[href=?]', '/time_entries'
               end
               test "#index by non-admin user without view_time_entries permission should not show overall spent time link" do
                 Role.find(2).remove_permission! :view_time_entries
                 Role.non_member.remove_permission! :view_time_entries
                 Role.anonymous.remove_permission! :view_time_entries
                 @request.session[:user_id] = 3
                 get :index
-                assert_template 'index'
                 assert_select 'a[href=?]', '/time_entries', 0
               end
               test "#index by non-admin user with permission should show add project link" do
                 Role.find(1).add_permission! :add_project
                 @request.session[:user_id] = 2
                 get :index
-                assert_template 'index'
                 assert_select 'a[href=?]', '/projects/new'
               end
               test "#new by admin user should accept get" do
                 @request.session[:user_id] = 1
                 get :new
                 assert_response :success
-                assert_template 'new'
+                assert_select 'input[name=?]', 'project[name]'
+                assert_select 'select[name=?]', 'project[parent_id]'
               end
               test "#new by non-admin user with add_project permission should accept get" do
                 Role.non_member.add_permission! :add_project
                 @request.session[:user_id] = 9
                 get :new
                 assert_response :success
-                assert_template 'new'
+                assert_select 'input[name=?]', 'project[name]'
                 assert_select 'select[name=?]', 'project[parent_id]', 0
               end
               test "#new by non-admin user with add_subprojects permission should accept get" do
                 Role.find(1).remove_permission! :add_project
                 Role.find(1).add_permission! :add_subprojects
                 @request.session[:user_id] = 2
                 get :new, :parent_id => 'ecookbook'
                 assert_response :success
-                assert_template 'new'
                 assert_select 'select[name=?]', 'project[parent_id]' do
                   # parent project selected
                   assert_select 'option[value="1"][selected=selected]'
                   # no empty value
                   assert_select 'option[value=""]', 0
                 end
               end
               def test_new_should_not_display_invalid_search_link
                 @request.session[:user_id] = 1
                 get :new
                 assert_response :success
                 assert_select '#quick-search form[action=?]', '/search'
                 assert_select '#quick-search a[href=?]', '/search'
               end
               test "#create by admin user should create a new project" do
                 @request.session[:user_id] = 1
                 post :create,
                   :project => {
                     :name => "blog",
                     :description => "weblog",
                     :homepage => 'http://weblog',
                     :identifier => "blog",
                     :is_public => 1,
                     :custom_field_values => { '3' => 'Beta' },
                     :tracker_ids => ['1', '3'],
                     # an issue custom field that is not for all project
                     :issue_custom_field_ids => ['9'],
                     :enabled_module_names => ['issue_tracking', 'news', 'repository']
                   }
                 assert_redirected_to '/projects/blog/settings'
                 project = Project.find_by_name('blog')
                 assert_kind_of Project, project
                 assert project.active?
                 assert_equal 'weblog', project.description
                 assert_equal 'http://weblog', project.homepage
                 assert_equal true, project.is_public?
                 assert_nil project.parent
                 assert_equal 'Beta', project.custom_value_for(3).value
                 assert_equal [1, 3], project.trackers.map(&:id).sort
                 assert_equal ['issue_tracking', 'news', 'repository'], project.enabled_module_names.sort
                 assert project.issue_custom_fields.include?(IssueCustomField.find(9))
               end
               test "#create by admin user should create a new subproject" do
                 @request.session[:user_id] = 1
                 assert_difference 'Project.count' do
                   post :create, :project => { :name => "blog",
                                            :description => "weblog",
                                            :identifier => "blog",
                                            :is_public => 1,
                                            :custom_field_values => { '3' => 'Beta' },
                                            :parent_id => 1
                                           }
                   assert_redirected_to '/projects/blog/settings'
                 end
                 project = Project.find_by_name('blog')
                 assert_kind_of Project, project
                 assert_equal Project.find(1), project.parent
               end
               test "#create by admin user should continue" do
                 @request.session[:user_id] = 1
                 assert_difference 'Project.count' do
                   post :create, :project => {:name => "blog", :identifier => "blog"}, :continue => 'Create and continue'
                 end
                 assert_redirected_to '/projects/new'
               end
               test "#create by non-admin user with add_project permission should create a new project" do
                 Role.non_member.add_permission! :add_project
                 @request.session[:user_id] = 9
                 post :create, :project => { :name => "blog",
                                          :description => "weblog",
                                          :identifier => "blog",
                                          :is_public => 1,
                                          :custom_field_values => { '3' => 'Beta' },
                                          :tracker_ids => ['1', '3'],
                                          :enabled_module_names => ['issue_tracking', 'news', 'repository']
                                         }
                 assert_redirected_to '/projects/blog/settings'
                 project = Project.find_by_name('blog')
                 assert_kind_of Project, project
                 assert_equal 'weblog', project.description
                 assert_equal true, project.is_public?
                 assert_equal [1, 3], project.trackers.map(&:id).sort
                 assert_equal ['issue_tracking', 'news', 'repository'], project.enabled_module_names.sort
                 # User should be added as a project member
                 assert User.find(9).member_of?(project)
                 assert_equal 1, project.members.size
               end
               test "#create by non-admin user with add_project permission should fail with parent_id" do
                 Role.non_member.add_permission! :add_project
+                User.find(9).update! :language => 'en'
                 @request.session[:user_id] = 9
                 assert_no_difference 'Project.count' do
                   post :create, :project => { :name => "blog",
                                            :description => "weblog",
                                            :identifier => "blog",
                                            :is_public => 1,
                                            :custom_field_values => { '3' => 'Beta' },
                                            :parent_id => 1
                                           }
                 end
                 assert_response :success
-                project = assigns(:project)
+                assert_select_error /Subproject of is invalid/
-                assert_kind_of Project, project
-                assert_not_equal [], project.errors[:parent_id]
               end
               test "#create by non-admin user with add_subprojects permission should create a project with a parent_id" do
                 Role.find(1).remove_permission! :add_project
                 Role.find(1).add_permission! :add_subprojects
                 @request.session[:user_id] = 2
                 post :create, :project => { :name => "blog",
                                          :description => "weblog",
                                          :identifier => "blog",
                                          :is_public => 1,
                                          :custom_field_values => { '3' => 'Beta' },
                                          :parent_id => 1
                                         }
                 assert_redirected_to '/projects/blog/settings'
                 project = Project.find_by_name('blog')
+                assert_equal 1, project.parent_id
               end
               test "#create by non-admin user with add_subprojects permission should fail without parent_id" do
                 Role.find(1).remove_permission! :add_project
                 Role.find(1).add_permission! :add_subprojects
                 @request.session[:user_id] = 2
                 assert_no_difference 'Project.count' do
                   post :create, :project => { :name => "blog",
                                            :description => "weblog",
                                            :identifier => "blog",
                                            :is_public => 1,
                                            :custom_field_values => { '3' => 'Beta' }
                                           }
                 end
                 assert_response :success
-                project = assigns(:project)
+                assert_select_error /Subproject of is invalid/
-                assert_kind_of Project, project
-                assert_not_equal [], project.errors[:parent_id]
               end
               test "#create by non-admin user with add_subprojects permission should fail with unauthorized parent_id" do
                 Role.find(1).remove_permission! :add_project
                 Role.find(1).add_permission! :add_subprojects
                 @request.session[:user_id] = 2
                 assert !User.find(2).member_of?(Project.find(6))
                 assert_no_difference 'Project.count' do
                   post :create, :project => { :name => "blog",
                                            :description => "weblog",
                                            :identifier => "blog",
                                            :is_public => 1,
                                            :custom_field_values => { '3' => 'Beta' },
                                            :parent_id => 6
                                           }
                 end
                 assert_response :success
-                project = assigns(:project)
+                assert_select_error /Subproject of is invalid/
-                assert_kind_of Project, project
-                assert_not_equal [], project.errors[:parent_id]
               end
               def test_create_subproject_with_inherit_members_should_inherit_members
                 Role.find_by_name('Manager').add_permission! :add_subprojects
                 parent = Project.find(1)
                 @request.session[:user_id] = 2
                 assert_difference 'Project.count' do
                   post :create, :project => {
                     :name => 'inherited', :identifier => 'inherited', :parent_id => parent.id, :inherit_members => '1'
                   }
                   assert_response 302
                 end
                 project = Project.order('id desc').first
                 assert_equal 'inherited', project.name
                 assert_equal parent, project.parent
                 assert project.memberships.count > 0
                 assert_equal parent.memberships.count, project.memberships.count
               end
               def test_create_should_preserve_modules_on_validation_failure
                 with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
                   @request.session[:user_id] = 1
                   assert_no_difference 'Project.count' do
                     post :create, :project => {
                       :name => "blog",
                       :identifier => "",
                       :enabled_module_names => %w(issue_tracking news)
                     }
                   end
                   assert_response :success
-                  project = assigns(:project)
+                  %w(issue_tracking news).each do |mod|
-                  assert_equal %w(issue_tracking news), project.enabled_module_names.sort
+                    assert_select 'input[name=?][value=?][checked=checked]', 'project[enabled_module_names][]', mod
+                  end
+                  assert_select 'input[name=?][checked=checked]', 'project[enabled_module_names][]', :count => 2
                 end
               end
               def test_show_by_id
                 get :show, :id => 1
                 assert_response :success
-                assert_template 'show'
+                assert_select '#header h1', :text => "eCookbook"
-                assert_not_nil assigns(:project)
               end
               def test_show_by_identifier
                 get :show, :id => 'ecookbook'
                 assert_response :success
-                assert_template 'show'
+                assert_select '#header h1', :text => "eCookbook"
-                assert_not_nil assigns(:project)
-                assert_equal Project.find_by_identifier('ecookbook'), assigns(:project)
-                assert_select 'li', :text => /Development status/
               end
               def test_show_should_not_display_empty_sidebar
                 p = Project.find(1)
                 p.enabled_module_names = []
                 p.save!
                 get :show, :id => 'ecookbook'
                 assert_response :success
                 assert_select '#main.nosidebar'
               end
+              def test_show_should_display_visible_custom_fields
+                ProjectCustomField.find_by_name('Development status').update_attribute :visible, true
+                get :show, :id => 'ecookbook'
+                assert_response :success
+                assert_select 'li', :text => /Development status/
+              end
               def test_show_should_not_display_hidden_custom_fields
                 ProjectCustomField.find_by_name('Development status').update_attribute :visible, false
                 get :show, :id => 'ecookbook'
                 assert_response :success
-                assert_template 'show'
-                assert_not_nil assigns(:project)
                 assert_select 'li', :text => /Development status/, :count => 0
               end
               def test_show_should_not_display_blank_custom_fields_with_multiple_values
                 f1 = ProjectCustomField.generate! :field_format => 'list', :possible_values => %w(Foo Bar), :multiple => true
                 f2 = ProjectCustomField.generate! :field_format => 'list', :possible_values => %w(Baz Qux), :multiple => true
                 project = Project.generate!(:custom_field_values => {f2.id.to_s => %w(Qux)})
                 get :show, :id => project.id
                 assert_response :success
                 assert_select 'li', :text => /#{f1.name}/, :count => 0
                 assert_select 'li', :text => /#{f2.name}/
               end
               def test_show_should_not_display_blank_text_custom_fields
                 f1 = ProjectCustomField.generate! :field_format => 'text'
                 get :show, :id => 1
                 assert_response :success
                 assert_select 'li', :text => /#{f1.name}/, :count => 0
               end
               def test_show_should_not_fail_when_custom_values_are_nil
                 project = Project.find_by_identifier('ecookbook')
                 project.custom_values.first.update_attribute(:value, nil)
                 get :show, :id => 'ecookbook'
                 assert_response :success
-                assert_template 'show'
-                assert_not_nil assigns(:project)
-                assert_equal Project.find_by_identifier('ecookbook'), assigns(:project)
               end
               def show_archived_project_should_be_denied
                 project = Project.find_by_identifier('ecookbook')
                 project.archive!
                 get :show, :id => 'ecookbook'
                 assert_response 403
-                assert_nil assigns(:project)
                 assert_select 'p', :text => /archived/
+                assert_not_include project.name, response.body
               end
               def test_show_should_not_show_private_subprojects_that_are_not_visible
                 get :show, :id => 'ecookbook'
                 assert_response :success
-                assert_template 'show'
                 assert_select 'a', :text => /Private child/, :count => 0
               end
               def test_show_should_show_private_subprojects_that_are_visible
                 @request.session[:user_id] = 2 # manager who is a member of the private subproject
                 get :show, :id => 'ecookbook'
                 assert_response :success
-                assert_template 'show'
                 assert_select 'a', :text => /Private child/
               end
               def test_settings
                 @request.session[:user_id] = 2 # manager
                 get :settings, :id => 1
                 assert_response :success
-                assert_template 'settings'
+                assert_select 'input[name=?]', 'project[name]'
               end
               def test_settings_of_subproject
                 @request.session[:user_id] = 2
                 get :settings, :id => 'private-child'
                 assert_response :success
-                assert_template 'settings'
                 assert_select 'input[type=checkbox][name=?]', 'project[inherit_members]'
               end
               def test_settings_should_be_denied_for_member_on_closed_project
                 Project.find(1).close
                 @request.session[:user_id] = 2 # manager
                 get :settings, :id => 1
                 assert_response 403
               end
               def test_settings_should_be_denied_for_anonymous_on_closed_project
                 Project.find(1).close
                 get :settings, :id => 1
                 assert_response 302
               end
               def test_setting_with_wiki_module_and_no_wiki
                 Project.find(1).wiki.destroy
                 Role.find(1).add_permission! :manage_wiki
                 @request.session[:user_id] = 2
                 get :settings, :id => 1
                 assert_response :success
-                assert_template 'settings'
                 assert_select 'form[action=?]', '/projects/ecookbook/wiki' do
                   assert_select 'input[name=?]', 'wiki[start_page]'
                 end
               end
               def test_update
                 @request.session[:user_id] = 2 # manager
                 post :update, :id => 1, :project => {:name => 'Test changed name',
                                                    :issue_custom_field_ids => ['']}
                 assert_redirected_to '/projects/ecookbook/settings'
                 project = Project.find(1)
                 assert_equal 'Test changed name', project.name
               end
               def test_update_with_failure
                 @request.session[:user_id] = 2 # manager
                 post :update, :id => 1, :project => {:name => ''}
                 assert_response :success
-                assert_template 'settings'
                 assert_select_error /name cannot be blank/i
               end
               def test_update_should_be_denied_for_member_on_closed_project
                 Project.find(1).close
                 @request.session[:user_id] = 2 # manager
                 post :update, :id => 1, :project => {:name => 'Closed'}
                 assert_response 403
                 assert_equal 'eCookbook', Project.find(1).name
               end
               def test_update_should_be_denied_for_anonymous_on_closed_project
                 Project.find(1).close
                 post :update, :id => 1, :project => {:name => 'Closed'}
                 assert_response 302
                 assert_equal 'eCookbook', Project.find(1).name
               end
               def test_update_child_project_without_parent_permission_should_not_show_validation_error
                 child = Project.generate_with_parent!
                 user = User.generate!
                 User.add_to_project(user, child, Role.generate!(:permissions => [:edit_project]))
                 @request.session[:user_id] = user.id
                 post :update, :id => child.id, :project => {:name => 'Updated'}
                 assert_response 302
                 assert_match /Successful update/, flash[:notice]
               end
               def test_modules
                 @request.session[:user_id] = 2
                 Project.find(1).enabled_module_names = ['issue_tracking', 'news']
                 post :modules, :id => 1, :enabled_module_names => ['issue_tracking', 'repository', 'documents']
                 assert_redirected_to '/projects/ecookbook/settings/modules'
                 assert_equal ['documents', 'issue_tracking', 'repository'], Project.find(1).enabled_module_names.sort
               end
               def test_destroy_leaf_project_without_confirmation_should_show_confirmation
                 @request.session[:user_id] = 1 # admin
                 assert_no_difference 'Project.count' do
                   delete :destroy, :id => 2
                   assert_response :success
-                  assert_template 'destroy'
                 end
+                assert_select '.warning', :text => /Are you sure you want to delete this project/
               end
               def test_destroy_without_confirmation_should_show_confirmation_with_subprojects
                 @request.session[:user_id] = 1 # admin
                 assert_no_difference 'Project.count' do
                   delete :destroy, :id => 1
                   assert_response :success
-                  assert_template 'destroy'
                 end
                 assert_select 'strong',
                               :text => ['Private child of eCookbook',
                                         'Child of private child, eCookbook Subproject 1',
                                         'eCookbook Subproject 2'].join(', ')
               end
               def test_destroy_with_confirmation_should_destroy_the_project_and_subprojects
                 @request.session[:user_id] = 1 # admin
                 assert_difference 'Project.count', -5 do
                   delete :destroy, :id => 1, :confirm => 1
                   assert_redirected_to '/admin/projects'
                 end
                 assert_nil Project.find_by_id(1)
               end
               def test_archive
                 @request.session[:user_id] = 1 # admin
                 post :archive, :id => 1
                 assert_redirected_to '/admin/projects'
                 assert !Project.find(1).active?
               end
               def test_archive_with_failure
                 @request.session[:user_id] = 1
                 Project.any_instance.stubs(:archive).returns(false)
                 post :archive, :id => 1
                 assert_redirected_to '/admin/projects'
                 assert_match /project cannot be archived/i, flash[:error]
               end
               def test_unarchive
                 @request.session[:user_id] = 1 # admin
                 Project.find(1).archive
                 post :unarchive, :id => 1
                 assert_redirected_to '/admin/projects'
                 assert Project.find(1).active?
               end
               def test_close
                 @request.session[:user_id] = 2
                 post :close, :id => 1
                 assert_redirected_to '/projects/ecookbook'
                 assert_equal Project::STATUS_CLOSED, Project.find(1).status
               end
               def test_reopen
                 Project.find(1).close
                 @request.session[:user_id] = 2
                 post :reopen, :id => 1
                 assert_redirected_to '/projects/ecookbook'
                 assert Project.find(1).active?
               end
               def test_project_breadcrumbs_should_be_limited_to_3_ancestors
                 CustomField.delete_all
                 parent = nil
 .times do |i|
                   p = Project.generate_with_parent!(parent)
                   get :show, :id => p
                   assert_select '#header h1' do
                     assert_select 'a', :count => [i, 3].min
                   end
                   parent = p
                 end
               end
               def test_get_copy
                 @request.session[:user_id] = 1 # admin
-                get :copy, :id => 1
+                orig = Project.find(1)
+                get :copy, :id => orig.id
                 assert_response :success
-                assert_template 'copy'
-                assert assigns(:project)
-                assert_equal Project.find(1).description, assigns(:project).description
-                assert_nil assigns(:project).id
+                assert_select 'textarea[name=?]', 'project[description]', :text => orig.description
                 assert_select 'input[name=?][value=?]', 'project[enabled_module_names][]', 'issue_tracking', 1
               end
               def test_get_copy_with_invalid_source_should_respond_with_404
                 @request.session[:user_id] = 1
                 get :copy, :id => 99
                 assert_response 404
               end
               def test_get_copy_should_preselect_custom_fields
                 field1 = IssueCustomField.generate!(:is_for_all => false)
                 field2 = IssueCustomField.generate!(:is_for_all => false)
                 source = Project.generate!(:issue_custom_fields => [field1])
                 @request.session[:user_id] = 1
                 get :copy, :id => source.id
                 assert_response :success
                 assert_select 'fieldset#project_issue_custom_fields' do
                   assert_select 'input[type=checkbox][value=?][checked=checked]', field1.id.to_s
                   assert_select 'input[type=checkbox][value=?]:not([checked])', field2.id.to_s
                 end
               end
               def test_post_copy_should_copy_requested_items
                 @request.session[:user_id] = 1 # admin
                 CustomField.delete_all
                 assert_difference 'Project.count' do
                   post :copy, :id => 1,
                     :project => {
                       :name => 'Copy',
                       :identifier => 'unique-copy',
                       :tracker_ids => ['1', '2', '3', ''],
                       :enabled_module_names => %w(issue_tracking time_tracking)
                     },
                     :only => %w(issues versions)
                 end
                 project = Project.find('unique-copy')
                 source = Project.find(1)
                 assert_equal %w(issue_tracking time_tracking), project.enabled_module_names.sort
                 assert_equal source.versions.count, project.versions.count, "All versions were not copied"
                 assert_equal source.issues.count, project.issues.count, "All issues were not copied"
                 assert_equal 0, project.members.count
               end
               def test_post_copy_should_redirect_to_settings_when_successful
                 @request.session[:user_id] = 1 # admin
                 post :copy, :id => 1, :project => {:name => 'Copy', :identifier => 'unique-copy'}
                 assert_response :redirect
                 assert_redirected_to :controller => 'projects', :action => 'settings', :id => 'unique-copy'
               end
               def test_post_copy_with_failure
                 @request.session[:user_id] = 1
                 post :copy, :id => 1, :project => {:name => 'Copy', :identifier => ''}
                 assert_response :success
-                assert_template 'copy'
+                assert_select_error /Identifier cannot be blank/
               end
               def test_jump_should_redirect_to_active_tab
                 get :show, :id => 1, :jump => 'issues'
                 assert_redirected_to '/projects/ecookbook/issues'
               end
               def test_jump_should_not_redirect_to_inactive_tab
                 get :show, :id => 3, :jump => 'documents'
                 assert_response :success
-                assert_template 'show'
               end
               def test_jump_should_not_redirect_to_unknown_tab
                 get :show, :id => 3, :jump => 'foobar'
                 assert_response :success
-                assert_template 'show'
               end
               def test_body_should_have_project_css_class
                 get :show, :id => 1
                 assert_select 'body.project-ecookbook'
               end
             end

test/functional/queries_controller_test.rb +9 -10

             # 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 QueriesControllerTest < Redmine::ControllerTest
               fixtures :projects, :users, :members, :member_roles, :roles, :trackers, :issue_statuses, :issue_categories, :enumerations, :issues, :custom_fields, :custom_values, :queries, :enabled_modules
               def setup
                 User.current = nil
               end
               def test_index
                 get :index
                 # HTML response not implemented
                 assert_response 406
               end
               def test_new_project_query
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1
                 assert_response :success
-                assert_template 'new'
                 assert_select 'input[name=?][value="0"][checked=checked]', 'query[visibility]'
                 assert_select 'input[name=query_is_for_all][type=checkbox]:not([checked]):not([disabled])'
                 assert_select 'select[name=?]', 'c[]' do
                   assert_select 'option[value=tracker]'
                   assert_select 'option[value=subject]'
                 end
               end
               def test_new_global_query
                 @request.session[:user_id] = 2
                 get :new
                 assert_response :success
-                assert_template 'new'
                 assert_select 'input[name=?]', 'query[visibility]', 0
                 assert_select 'input[name=query_is_for_all][type=checkbox][checked]:not([disabled])'
               end
               def test_new_on_invalid_project
                 @request.session[:user_id] = 2
                 get :new, :project_id => 'invalid'
                 assert_response 404
               end
               def test_new_time_entry_query
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :type => 'TimeEntryQuery'
                 assert_response :success
                 assert_select 'input[name=type][value=?]', 'TimeEntryQuery'
               end
               def test_create_project_public_query
                 @request.session[:user_id] = 2
                 post :create,
                      :project_id => 'ecookbook',
                      :default_columns => '1',
                      :f => ["status_id", "assigned_to_id"],
                      :op => {"assigned_to_id" => "=", "status_id" => "o"},
                      :v => { "assigned_to_id" => ["1"], "status_id" => ["1"]},
                      :query => {"name" => "test_new_project_public_query", "visibility" => "2"}
                 q = Query.find_by_name('test_new_project_public_query')
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook', :query_id => q
                 assert q.is_public?
                 assert q.has_default_columns?
                 assert q.valid?
               end
               def test_create_project_private_query
                 @request.session[:user_id] = 3
                 post :create,
                      :project_id => 'ecookbook',
                      :default_columns => '1',
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["1"], "status_id" => ["1"]},
                      :query => {"name" => "test_new_project_private_query", "visibility" => "0"}
                 q = Query.find_by_name('test_new_project_private_query')
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook', :query_id => q
                 assert !q.is_public?
                 assert q.has_default_columns?
                 assert q.valid?
               end
               def test_create_project_roles_query
                 @request.session[:user_id] = 2
                 post :create,
                      :project_id => 'ecookbook',
                      :default_columns => '1',
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["1"], "status_id" => ["1"]},
                      :query => {"name" => "test_create_project_roles_query", "visibility" => "1", "role_ids" => ["1", "2", ""]}
                 q = Query.find_by_name('test_create_project_roles_query')
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook', :query_id => q
                 assert_equal Query::VISIBILITY_ROLES, q.visibility
                 assert_equal [1, 2], q.roles.ids.sort
               end
               def test_create_global_private_query_with_custom_columns
                 @request.session[:user_id] = 3
                 post :create,
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["me"], "status_id" => ["1"]},
                      :query => {"name" => "test_new_global_private_query", "visibility" => "0"},
                      :c => ["", "tracker", "subject", "priority", "category"]
                 q = Query.find_by_name('test_new_global_private_query')
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => nil, :query_id => q
                 assert !q.is_public?
                 assert !q.has_default_columns?
                 assert_equal [:id, :tracker, :subject, :priority, :category], q.columns.collect {|c| c.name}
                 assert q.valid?
               end
               def test_create_global_query_with_custom_filters
                 @request.session[:user_id] = 3
                 post :create,
                      :fields => ["assigned_to_id"],
                      :operators => {"assigned_to_id" => "="},
                      :values => { "assigned_to_id" => ["me"]},
                      :query => {"name" => "test_new_global_query"}
                 q = Query.find_by_name('test_new_global_query')
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => nil, :query_id => q
                 assert !q.is_public?
                 assert !q.has_filter?(:status_id)
                 assert_equal ['assigned_to_id'], q.filters.keys
                 assert q.valid?
               end
               def test_create_with_sort
                 @request.session[:user_id] = 1
                 post :create,
                      :default_columns => '1',
                      :operators => {"status_id" => "o"},
                      :values => {"status_id" => ["1"]},
                      :query => {:name => "test_new_with_sort",
                                 :visibility => "2",
                                 :sort_criteria => {"0" => ["due_date", "desc"], "1" => ["tracker", ""]}}
                 query = Query.find_by_name("test_new_with_sort")
                 assert_not_nil query
                 assert_equal [['due_date', 'desc'], ['tracker', 'asc']], query.sort_criteria
               end
               def test_create_with_failure
                 @request.session[:user_id] = 2
                 assert_no_difference '::Query.count' do
                   post :create, :project_id => 'ecookbook', :query => {:name => ''}
                 end
                 assert_response :success
-                assert_template 'new'
                 assert_select 'input[name=?]', 'query[name]'
               end
               def test_create_global_query_from_gantt
                 @request.session[:user_id] = 1
                 assert_difference 'IssueQuery.count' do
                   post :create,
                        :gantt => 1,
                        :operators => {"status_id" => "o"},
                        :values => {"status_id" => ["1"]},
                        :query => {:name => "test_create_from_gantt",
                                   :draw_relations => '1',
                                   :draw_progress_line => '1'}
                   assert_response 302
                 end
                 query = IssueQuery.order('id DESC').first
                 assert_redirected_to "/issues/gantt?query_id=#{query.id}"
                 assert_equal true, query.draw_relations
                 assert_equal true, query.draw_progress_line
               end
               def test_create_project_query_from_gantt
                 @request.session[:user_id] = 1
                 assert_difference 'IssueQuery.count' do
                   post :create,
                        :project_id => 'ecookbook',
                        :gantt => 1,
                        :operators => {"status_id" => "o"},
                        :values => {"status_id" => ["1"]},
                        :query => {:name => "test_create_from_gantt",
                                   :draw_relations => '0',
                                   :draw_progress_line => '0'}
                   assert_response 302
                 end
                 query = IssueQuery.order('id DESC').first
                 assert_redirected_to "/projects/ecookbook/issues/gantt?query_id=#{query.id}"
                 assert_equal false, query.draw_relations
                 assert_equal false, query.draw_progress_line
               end
               def test_create_project_public_query_should_force_private_without_manage_public_queries_permission
                 @request.session[:user_id] = 3
                 query = new_record(Query) do
                   post :create,
                        :project_id => 'ecookbook',
                        :query => {"name" => "name", "visibility" => "2"}
                   assert_response 302
                 end
                 assert_not_nil query.project
                 assert_equal Query::VISIBILITY_PRIVATE, query.visibility
               end
               def test_create_global_public_query_should_force_private_without_manage_public_queries_permission
                 @request.session[:user_id] = 3
                 query = new_record(Query) do
                   post :create,
                        :project_id => 'ecookbook', :query_is_for_all => '1',
                        :query => {"name" => "name", "visibility" => "2"}
                   assert_response 302
                 end
                 assert_nil query.project
                 assert_equal Query::VISIBILITY_PRIVATE, query.visibility
               end
               def test_create_project_public_query_with_manage_public_queries_permission
                 @request.session[:user_id] = 2
                 query = new_record(Query) do
                   post :create,
                        :project_id => 'ecookbook',
                        :query => {"name" => "name", "visibility" => "2"}
                   assert_response 302
                 end
                 assert_not_nil query.project
                 assert_equal Query::VISIBILITY_PUBLIC, query.visibility
               end
               def test_create_global_public_query_should_force_private_with_manage_public_queries_permission
                 @request.session[:user_id] = 2
                 query = new_record(Query) do
                   post :create,
                        :project_id => 'ecookbook', :query_is_for_all => '1',
                        :query => {"name" => "name", "visibility" => "2"}
                   assert_response 302
                 end
                 assert_nil query.project
                 assert_equal Query::VISIBILITY_PRIVATE, query.visibility
               end
               def test_create_global_public_query_by_admin
                 @request.session[:user_id] = 1
                 query = new_record(Query) do
                   post :create,
                        :project_id => 'ecookbook', :query_is_for_all => '1',
                        :query => {"name" => "name", "visibility" => "2"}
                   assert_response 302
                 end
                 assert_nil query.project
                 assert_equal Query::VISIBILITY_PUBLIC, query.visibility
               end
               def test_create_project_public_time_entry_query
                 @request.session[:user_id] = 2
                 q = new_record(TimeEntryQuery) do
                   post :create,
                        :project_id => 'ecookbook',
                        :type => 'TimeEntryQuery',
                        :default_columns => '1',
                        :f => ["spent_on"],
                        :op => {"spent_on" => "="},
                        :v => { "spent_on" => ["2016-07-14"]},
                        :query => {"name" => "test_new_project_public_query", "visibility" => "2"}
                 end
                 assert_redirected_to :controller => 'timelog', :action => 'index', :project_id => 'ecookbook', :query_id => q.id
                 assert q.is_public?
                 assert q.has_default_columns?
                 assert q.valid?
               end
               def test_edit_global_public_query
                 @request.session[:user_id] = 1
                 get :edit, :id => 4
                 assert_response :success
-                assert_template 'edit'
                 assert_select 'input[name=?][value="2"][checked=checked]', 'query[visibility]'
                 assert_select 'input[name=query_is_for_all][type=checkbox][checked=checked]'
               end
               def test_edit_global_private_query
                 @request.session[:user_id] = 3
                 get :edit, :id => 3
                 assert_response :success
-                assert_template 'edit'
                 assert_select 'input[name=?]', 'query[visibility]', 0
                 assert_select 'input[name=query_is_for_all][type=checkbox][checked=checked]'
               end
               def test_edit_project_private_query
                 @request.session[:user_id] = 3
                 get :edit, :id => 2
                 assert_response :success
-                assert_template 'edit'
                 assert_select 'input[name=?]', 'query[visibility]', 0
                 assert_select 'input[name=query_is_for_all][type=checkbox]:not([checked])'
               end
               def test_edit_project_public_query
                 @request.session[:user_id] = 2
                 get :edit, :id => 1
                 assert_response :success
-                assert_template 'edit'
                 assert_select 'input[name=?][value="2"][checked=checked]', 'query[visibility]'
                 assert_select 'input[name=query_is_for_all][type=checkbox]:not([checked])'
               end
               def test_edit_sort_criteria
                 @request.session[:user_id] = 1
                 get :edit, :id => 5
                 assert_response :success
-                assert_template 'edit'
                 assert_select 'select[name=?]', 'query[sort_criteria][0][]' do
                   assert_select 'option[value=priority][selected=selected]'
                   assert_select 'option[value=desc][selected=selected]'
                 end
               end
               def test_edit_invalid_query
                 @request.session[:user_id] = 2
                 get :edit, :id => 99
                 assert_response 404
               end
               def test_udpate_global_private_query
                 @request.session[:user_id] = 3
                 put :update,
                      :id => 3,
                      :default_columns => '1',
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["me"], "status_id" => ["1"]},
                      :query => {"name" => "test_edit_global_private_query", "visibility" => "2"}
                 assert_redirected_to :controller => 'issues', :action => 'index', :query_id => 3
                 q = Query.find_by_name('test_edit_global_private_query')
                 assert !q.is_public?
                 assert q.has_default_columns?
                 assert q.valid?
               end
               def test_update_global_public_query
                 @request.session[:user_id] = 1
                 put :update,
                      :id => 4,
                      :default_columns => '1',
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["1"], "status_id" => ["1"]},
                      :query => {"name" => "test_edit_global_public_query", "visibility" => "2"}
                 assert_redirected_to :controller => 'issues', :action => 'index', :query_id => 4
                 q = Query.find_by_name('test_edit_global_public_query')
                 assert q.is_public?
                 assert q.has_default_columns?
                 assert q.valid?
               end
               def test_update_with_failure
                 @request.session[:user_id] = 1
                 put :update, :id => 4, :query => {:name => ''}
                 assert_response :success
-                assert_template 'edit'
+                assert_select_error /Name cannot be blank/
               end
               def test_destroy
                 @request.session[:user_id] = 2
                 delete :destroy, :id => 1
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook', :set_filter => 1, :query_id => nil
                 assert_nil Query.find_by_id(1)
               end
               def test_backslash_should_be_escaped_in_filters
                 @request.session[:user_id] = 2
                 get :new, :subject => 'foo/bar'
                 assert_response :success
-                assert_template 'new'
                 assert_include 'addFilter("subject", "=", ["foo\/bar"]);', response.body
               end
             end

test/functional/reports_controller_test.rb +1 -22

             # 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 ReportsControllerTest < Redmine::ControllerTest
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :versions
               def test_get_issue_report
                 get :issue_report, :id => 1
                 assert_response :success
-                assert_template 'issue_report'
-                [:issues_by_tracker, :issues_by_version, :issues_by_category, :issues_by_assigned_to,
-                 :issues_by_author, :issues_by_subproject, :issues_by_priority].each do |ivar|
-                  assert_not_nil assigns(ivar)
-                end
-                assert_equal IssuePriority.all.reverse, assigns(:priorities)
               end
               def test_get_issue_report_details
                 %w(tracker version priority category assigned_to author subproject).each do |detail|
                   get :issue_report_details, :id => 1, :detail => detail
                   assert_response :success
-                  assert_template 'issue_report_details'
-                  assert_not_nil assigns(:field)
-                  assert_not_nil assigns(:rows)
-                  assert_not_nil assigns(:data)
-                  assert_not_nil assigns(:report_title)
                 end
               end
               def test_get_issue_report_details_by_tracker_should_show_issue_count
                 Issue.delete_all
                 Issue.generate!(:tracker_id => 1)
                 Issue.generate!(:tracker_id => 1)
                 Issue.generate!(:tracker_id => 1, :status_id => 5)
                 Issue.generate!(:tracker_id => 2)
                 get :issue_report_details, :id => 1, :detail => 'tracker'
                 assert_select 'table.list tbody :nth-child(1)' do
                   assert_select 'td', :text => 'Bug'
                   assert_select ':nth-child(2)', :text => '2' # status:1
                   assert_select ':nth-child(3)', :text => '-' # status:2
                   assert_select ':nth-child(8)', :text => '2' # open
                   assert_select ':nth-child(9)', :text => '1' # closed
                   assert_select ':nth-child(10)', :text => '3' # total
                 end
               end
-              def test_get_issue_report_details_by_priority
-                get :issue_report_details, :id => 1, :detail => 'priority'
-                assert_equal IssuePriority.all.reverse, assigns(:rows)
-              end
               def test_get_issue_report_details_with_an_invalid_detail
                 get :issue_report_details, :id => 1, :detail => 'invalid'
+                assert_response 404
-                assert_redirected_to '/projects/ecookbook/issues/report'
               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