jro_apps/redmine Commit - r10758:24be0551ccd7

Code cleanup....

Jean-Philippe Lang -

r10758:24be0551ccd7

parent child

Context file:

r10758:24be0551ccd7

Collapse all files

app/controllers/queries_controller.rb 0 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 QueriesController < ApplicationController
               menu_item :issues
               before_filter :find_query, :except => [:new, :create, :index]
               before_filter :find_optional_project, :only => [:new, :create]
               accept_api_auth :index
               include QueriesHelper
               def index
                 case params[:format]
                 when 'xml', 'json'
                   @offset, @limit = api_offset_and_limit
                 else
                   @limit = per_page_option
                 end
                 @query_count = IssueQuery.visible.count
                 @query_pages = Paginator.new self, @query_count, @limit, params['page']
                 @queries = IssueQuery.visible.all(:limit => @limit, :offset => @offset, :order => "#{Query.table_name}.name")
                 respond_to do |format|
-                  format.html { render :nothing => true }
                   format.api
                 end
               end
               def new
                 @query = IssueQuery.new
                 @query.user = User.current
                 @query.project = @project
                 @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
                 @query.build_from_params(params)
               end
               def create
                 @query = IssueQuery.new(params[:query])
                 @query.user = User.current
                 @query.project = params[:query_is_for_all] ? nil : @project
                 @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
                 @query.build_from_params(params)
                 @query.column_names = nil if params[:default_columns]
                 if @query.save
                   flash[:notice] = l(:notice_successful_create)
                   redirect_to _issues_path(@project, :query_id => @query)
                 else
                   render :action => 'new', :layout => !request.xhr?
                 end
               end
               def edit
               end
               def update
                 @query.attributes = params[:query]
                 @query.project = nil if params[:query_is_for_all]
                 @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?
                 @query.build_from_params(params)
                 @query.column_names = nil if params[:default_columns]
                 if @query.save
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to _issues_path(@project, :query_id => @query)
                 else
                   render :action => 'edit'
                 end
               end
               def destroy
                 @query.destroy
                 redirect_to _issues_path(@project, :set_filter => 1)
               end
             private
               def find_query
                 @query = IssueQuery.find(params[:id])
                 @project = @query.project
                 render_403 unless @query.editable_by?(User.current)
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_optional_project
                 @project = Project.find(params[:project_id]) if params[:project_id]
                 render_403 unless User.current.allowed_to?(:save_queries, @project, :global => true)
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/controllers/workflows_controller.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 WorkflowsController < ApplicationController
               layout 'admin'
               before_filter :require_admin, :find_roles, :find_trackers
               def index
                 @workflow_counts = WorkflowTransition.count_by_tracker_and_role
               end
               def edit
                 @role = Role.find_by_id(params[:role_id]) if params[:role_id]
                 @tracker = Tracker.find_by_id(params[:tracker_id]) if params[:tracker_id]
                 if request.post?
                   WorkflowTransition.destroy_all( ["role_id=? and tracker_id=?", @role.id, @tracker.id])
                   (params[:issue_status] || []).each { |status_id, transitions|
                     transitions.each { |new_status_id, options|
                       author = options.is_a?(Array) && options.include?('author') && !options.include?('always')
                       assignee = options.is_a?(Array) && options.include?('assignee') && !options.include?('always')
                       WorkflowTransition.create(:role_id => @role.id, :tracker_id => @tracker.id, :old_status_id => status_id, :new_status_id => new_status_id, :author => author, :assignee => assignee)
                     }
                   }
                   if @role.save
                     redirect_to workflows_edit_path(:role_id => @role, :tracker_id => @tracker, :used_statuses_only => params[:used_statuses_only])
                     return
                   end
                 end
                 @used_statuses_only = (params[:used_statuses_only] == '0' ? false : true)
                 if @tracker && @used_statuses_only && @tracker.issue_statuses.any?
                   @statuses = @tracker.issue_statuses
                 end
                 @statuses ||= IssueStatus.sorted.all
                 if @tracker && @role && @statuses.any?
                   workflows = WorkflowTransition.where(:role_id => @role.id, :tracker_id => @tracker.id).all
                   @workflows = {}
                   @workflows['always'] = workflows.select {|w| !w.author && !w.assignee}
                   @workflows['author'] = workflows.select {|w| w.author}
                   @workflows['assignee'] = workflows.select {|w| w.assignee}
                 end
               end
               def permissions
                 @role = Role.find_by_id(params[:role_id]) if params[:role_id]
                 @tracker = Tracker.find_by_id(params[:tracker_id]) if params[:tracker_id]
                 if request.post? && @role && @tracker
                   WorkflowPermission.replace_permissions(@tracker, @role, params[:permissions] || {})
                   redirect_to workflows_permissions_path(:role_id => @role, :tracker_id => @tracker, :used_statuses_only => params[:used_statuses_only])
                   return
                 end
                 @used_statuses_only = (params[:used_statuses_only] == '0' ? false : true)
                 if @tracker && @used_statuses_only && @tracker.issue_statuses.any?
                   @statuses = @tracker.issue_statuses
                 end
                 @statuses ||= IssueStatus.sorted.all
                 if @role && @tracker
                   @fields = (Tracker::CORE_FIELDS_ALL - @tracker.disabled_core_fields).map {|field| [field, l("field_"+field.sub(/_id$/, ''))]}
                   @custom_fields = @tracker.custom_fields
                   @permissions = WorkflowPermission.where(:tracker_id => @tracker.id, :role_id => @role.id).all.inject({}) do |h, w|
                     h[w.old_status_id] ||= {}
                     h[w.old_status_id][w.field_name] = w.rule
                     h
                   end
                   @statuses.each {|status| @permissions[status.id] ||= {}}
                 end
               end
               def copy
                 if params[:source_tracker_id].blank? || params[:source_tracker_id] == 'any'
                   @source_tracker = nil
                 else
                   @source_tracker = Tracker.find_by_id(params[:source_tracker_id].to_i)
                 end
                 if params[:source_role_id].blank? || params[:source_role_id] == 'any'
                   @source_role = nil
                 else
                   @source_role = Role.find_by_id(params[:source_role_id].to_i)
                 end
                 @target_trackers = params[:target_tracker_ids].blank? ? nil : Tracker.find_all_by_id(params[:target_tracker_ids])
                 @target_roles = params[:target_role_ids].blank? ? nil : Role.find_all_by_id(params[:target_role_ids])
                 if request.post?
                   if params[:source_tracker_id].blank? || params[:source_role_id].blank? || (@source_tracker.nil? && @source_role.nil?)
                     flash.now[:error] = l(:error_workflow_copy_source)
-                  elsif @target_trackers.nil? || @target_roles.nil?
+                  elsif @target_trackers.blank? || @target_roles.blank?
                     flash.now[:error] = l(:error_workflow_copy_target)
                   else
                     WorkflowRule.copy(@source_tracker, @source_role, @target_trackers, @target_roles)
                     flash[:notice] = l(:notice_successful_update)
                     redirect_to workflows_copy_path(:source_tracker_id => @source_tracker, :source_role_id => @source_role)
                   end
                 end
               end
               private
               def find_roles
                 @roles = Role.sorted.all
               end
               def find_trackers
                 @trackers = Tracker.sorted.all
               end
             end

test/functional/messages_controller_test.rb +6 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 < ActionController::TestCase
               fixtures :projects, :users, :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_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_tag 'input', :attributes => {:id => 'message_subject'}
                 assert_tag 'textarea', :attributes => {:id => 'message_content'}
                 assert_tag 'div', :attributes => {:id => '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.last(:order => 'id').id
                 assert_response :success
                 assert_template 'show'
                 replies = assigns(:replies)
                 assert_not_nil replies
                 assert !replies.include?(message.children.first(:order => 'id'))
                 assert replies.include?(message.children.last(:order => 'id'))
               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_tag :div, :attributes => { :id => 'reply' },
                                  :descendant => { :tag => 'textarea', :attributes => { :id => 'message_content' } }
               end
               def test_show_message_not_found
                 get :show, :board_id => 1, :id => 99999
                 assert_response 404
               end
               def test_get_new
                 @request.session[:user_id] = 2
                 get :new, :board_id => 1
                 assert_response :success
                 assert_template 'new'
               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'
               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'
               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'
               end
             end

test/functional/queries_controller_test.rb +6 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  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 < ActionController::TestCase
               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_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query[is_public]',
                                                              :checked => nil }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => nil,
                                                              :disabled => nil }
                 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_no_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                                 :name => 'query[is_public]' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => 'checked',
                                                              :disabled => nil }
               end
               def test_new_on_invalid_project
                 @request.session[:user_id] = 2
                 get :new, :project_id => 'invalid'
                 assert_response 404
               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", "is_public" => "1"}
                 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", "is_public" => "1"}
                 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_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", "is_public" => "1"},
                      :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 [: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.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",
                                 :is_public => "1",
                                 :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_edit_global_public_query
                 @request.session[:user_id] = 1
                 get :edit, :id => 4
                 assert_response :success
                 assert_template 'edit'
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query[is_public]',
                                                              :checked => 'checked' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => 'checked',
                                                              :disabled => 'disabled' }
               end
               def test_edit_global_private_query
                 @request.session[:user_id] = 3
                 get :edit, :id => 3
                 assert_response :success
                 assert_template 'edit'
                 assert_no_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                                 :name => 'query[is_public]' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => 'checked',
                                                              :disabled => 'disabled' }
               end
               def test_edit_project_private_query
                 @request.session[:user_id] = 3
                 get :edit, :id => 2
                 assert_response :success
                 assert_template 'edit'
                 assert_no_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                                 :name => 'query[is_public]' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => nil,
                                                              :disabled => nil }
               end
               def test_edit_project_public_query
                 @request.session[:user_id] = 2
                 get :edit, :id => 1
                 assert_response :success
                 assert_template 'edit'
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query[is_public]',
                                                              :checked => 'checked'
                                                               }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => nil,
                                                              :disabled => 'disabled' }
               end
               def test_edit_sort_criteria
                 @request.session[:user_id] = 1
                 get :edit, :id => 5
                 assert_response :success
                 assert_template 'edit'
                 assert_tag :tag => 'select', :attributes => { :name => 'query[sort_criteria][0][]' },
                                              :child => { :tag => 'option', :attributes => { :value => 'priority',
                                                                                             :selected => 'selected' } }
                 assert_tag :tag => 'select', :attributes => { :name => 'query[sort_criteria][0][]' },
                                              :child => { :tag => 'option', :attributes => { :value => 'desc',
                                                                                             :selected => 'selected' } }
               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", "is_public" => "1"}
                 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", "is_public" => "1"}
                 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'
               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/workflows_controller_test.rb +20 0

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

General Comments 0

Write
Preview

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

No TODOs yet

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

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