jro_apps/redmine Commit - r8418:065376c160b0

Copy issues via bulk update action....

Jean-Philippe Lang -

r8418:065376c160b0

parent child

Context file:

r8418:065376c160b0

Collapse all files

app/controllers/issues_controller.rb +7 -2

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 IssuesController < ApplicationController
               menu_item :new_issue, :only => [:new, :create]
               default_search_scope :issues
               before_filter :find_issue, :only => [:show, :edit, :update]
               before_filter :find_issues, :only => [:bulk_edit, :bulk_update, :move, :perform_move, :destroy]
               before_filter :check_project_uniqueness, :only => [:move, :perform_move]
               before_filter :find_project, :only => [:new, :create]
               before_filter :authorize, :except => [:index]
               before_filter :find_optional_project, :only => [:index]
               before_filter :check_for_default_issue_status, :only => [:new, :create]
               before_filter :build_new_issue_from_params, :only => [:new, :create]
               accept_rss_auth :index, :show
               accept_api_auth :index, :show, :create, :update, :destroy
               rescue_from Query::StatementInvalid, :with => :query_statement_invalid
               helper :journals
               helper :projects
               include ProjectsHelper
               helper :custom_fields
               include CustomFieldsHelper
               helper :issue_relations
               include IssueRelationsHelper
               helper :watchers
               include WatchersHelper
               helper :attachments
               include AttachmentsHelper
               helper :queries
               include QueriesHelper
               helper :repositories
               include RepositoriesHelper
               helper :sort
               include SortHelper
               include IssuesHelper
               helper :timelog
               helper :gantt
               include Redmine::Export::PDF
               verify :method => :post, :only => :create, :render => {:nothing => true, :status => :method_not_allowed }
               verify :method => :post, :only => :bulk_update, :render => {:nothing => true, :status => :method_not_allowed }
               verify :method => :put, :only => :update, :render => {:nothing => true, :status => :method_not_allowed }
               def index
                 retrieve_query
                 sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
                 sort_update(@query.sortable_columns)
                 if @query.valid?
                   case params[:format]
                   when 'csv', 'pdf'
                     @limit = Setting.issues_export_limit.to_i
                   when 'atom'
                     @limit = Setting.feeds_limit.to_i
                   when 'xml', 'json'
                     @offset, @limit = api_offset_and_limit
                   else
                     @limit = per_page_option
                   end
                   @issue_count = @query.issue_count
                   @issue_pages = Paginator.new self, @issue_count, @limit, params['page']
                   @offset ||= @issue_pages.current.offset
                   @issues = @query.issues(:include => [:assigned_to, :tracker, :priority, :category, :fixed_version],
                                           :order => sort_clause,
                                           :offset => @offset,
                                           :limit => @limit)
                   @issue_count_by_group = @query.issue_count_by_group
                   respond_to do |format|
                     format.html { render :template => 'issues/index', :layout => !request.xhr? }
                     format.api  {
                       Issue.load_relations(@issues) if include_in_api_response?('relations')
                     }
                     format.atom { render_feed(@issues, :title => "#{@project || Setting.app_title}: #{l(:label_issue_plural)}") }
                     format.csv  { send_data(issues_to_csv(@issues, @project, @query, params), :type => 'text/csv; header=present', :filename => 'export.csv') }
                     format.pdf  { send_data(issues_to_pdf(@issues, @project, @query), :type => 'application/pdf', :filename => 'export.pdf') }
                   end
                 else
                   respond_to do |format|
                     format.html { render(:template => 'issues/index', :layout => !request.xhr?) }
                     format.any(:atom, :csv, :pdf) { render(:nothing => true) }
                     format.api { render_validation_errors(@query) }
                   end
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def show
                 @journals = @issue.journals.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")
                 @journals.each_with_index {|j,i| j.indice = i+1}
                 @journals.reverse! if User.current.wants_comments_in_reverse_order?
                 if User.current.allowed_to?(:view_changesets, @project)
                   @changesets = @issue.changesets.visible.all
                   @changesets.reverse! if User.current.wants_comments_in_reverse_order?
                 end
                 @relations = @issue.relations.select {|r| r.other_issue(@issue) && r.other_issue(@issue).visible? }
                 @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                 @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                 @priorities = IssuePriority.active
                 @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
                 respond_to do |format|
                   format.html {
                     retrieve_previous_and_next_issue_ids
                     render :template => 'issues/show'
                   }
                   format.api
                   format.atom { render :template => 'journals/index', :layout => false, :content_type => 'application/atom+xml' }
                   format.pdf  { send_data(issue_to_pdf(@issue), :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf") }
                 end
               end
               # Add a new issue
               # The new issue will be created from an existing one if copy_from parameter is given
               def new
                 respond_to do |format|
                   format.html { render :action => 'new', :layout => !request.xhr? }
                   format.js {
                     render(:update) { |page|
                       if params[:project_change]
                         page.replace_html 'all_attributes', :partial => 'form'
                       else
                         page.replace_html 'attributes', :partial => 'attributes'
                       end
                       m = User.current.allowed_to?(:log_time, @issue.project) ? 'show' : 'hide'
                       page << "if ($('log_time')) {Element.#{m}('log_time');}"
                     }
                   }
                 end
               end
               def create
                 call_hook(:controller_issues_new_before_save, { :params => params, :issue => @issue })
                 if @issue.save
                   attachments = Attachment.attach_files(@issue, params[:attachments])
                   call_hook(:controller_issues_new_after_save, { :params => params, :issue => @issue})
                   respond_to do |format|
                     format.html {
                       render_attachment_warning_if_needed(@issue)
                       flash[:notice] = l(:notice_issue_successful_create, :id => "<a href='#{issue_path(@issue)}'>##{@issue.id}</a>")
                       redirect_to(params[:continue] ?  { :action => 'new', :project_id => @project, :issue => {:tracker_id => @issue.tracker, :parent_issue_id => @issue.parent_issue_id}.reject {|k,v| v.nil?} } :
                                   { :action => 'show', :id => @issue })
                     }
                     format.api  { render :action => 'show', :status => :created, :location => issue_url(@issue) }
                   end
                   return
                 else
                   respond_to do |format|
                     format.html { render :action => 'new' }
                     format.api  { render_validation_errors(@issue) }
                   end
                 end
               end
               def edit
                 update_issue_from_params
                 @journal = @issue.current_journal
                 respond_to do |format|
                   format.html { }
                   format.xml  { }
                 end
               end
               def update
                 update_issue_from_params
                 if @issue.save_issue_with_child_records(params, @time_entry)
                   render_attachment_warning_if_needed(@issue)
                   flash[:notice] = l(:notice_successful_update) unless @issue.current_journal.new_record?
                   respond_to do |format|
                     format.html { redirect_back_or_default({:action => 'show', :id => @issue}) }
                     format.api  { head :ok }
                   end
                 else
                   render_attachment_warning_if_needed(@issue)
                   flash[:notice] = l(:notice_successful_update) unless @issue.current_journal.new_record?
                   @journal = @issue.current_journal
                   respond_to do |format|
                     format.html { render :action => 'edit' }
                     format.api  { render_validation_errors(@issue) }
                   end
                 end
               end
-              # Bulk edit a set of issues
+              # Bulk edit/copy a set of issues
               def bulk_edit
                 @issues.sort!
+                @copy = params[:copy].present?
+                @notes = params[:notes]
                 if User.current.allowed_to?(:move_issues, @projects)
                   @allowed_projects = Issue.allowed_target_projects_on_move
                   if params[:issue]
                     @target_project = @allowed_projects.detect {|p| p.id.to_s == params[:issue][:project_id]}
                     if @target_project
                       target_projects = [@target_project]
                     end
                   end
                 end
                 target_projects ||= @projects
                 @available_statuses = target_projects.map{|p|Workflow.available_statuses(p)}.inject{|memo,w|memo & w}
                 @custom_fields = target_projects.map{|p|p.all_issue_custom_fields}.inject{|memo,c|memo & c}
                 @assignables = target_projects.map(&:assignable_users).inject{|memo,a| memo & a}
                 @trackers = target_projects.map(&:trackers).inject{|memo,t| memo & t}
-                @notes = params[:notes]
                 render :layout => false if request.xhr?
               end
               def bulk_update
                 @issues.sort!
+                @copy = params[:copy].present?
                 attributes = parse_params_for_bulk_issue_attributes(params)
                 unsaved_issue_ids = []
                 moved_issues = []
                 @issues.each do |issue|
                   issue.reload
+                  if @copy
+                    issue = Issue.new.copy_from(issue)
+                  end
                   journal = issue.init_journal(User.current, params[:notes])
                   issue.safe_attributes = attributes
                   call_hook(:controller_issues_bulk_edit_before_save, { :params => params, :issue => issue })
                   if issue.save
                     moved_issues << issue
                   else
                     # Keep unsaved issue ids to display them in flash error
                     unsaved_issue_ids << issue.id
                   end
                 end
                 set_flash_from_bulk_issue_save(@issues, unsaved_issue_ids)
                 if params[:follow]
                   if @issues.size == 1 && moved_issues.size == 1
                     redirect_to :controller => 'issues', :action => 'show', :id => moved_issues.first
                   elsif moved_issues.map(&:project).uniq.size == 1
                     redirect_to :controller => 'issues', :action => 'index', :project_id => moved_issues.map(&:project).first
                   end
                 else
                   redirect_back_or_default({:controller => 'issues', :action => 'index', :project_id => @project})
                 end
               end
               verify :method => :delete, :only => :destroy, :render => { :nothing => true, :status => :method_not_allowed }
               def destroy
                 @hours = TimeEntry.sum(:hours, :conditions => ['issue_id IN (?)', @issues]).to_f
                 if @hours > 0
                   case params[:todo]
                   when 'destroy'
                     # nothing to do
                   when 'nullify'
                     TimeEntry.update_all('issue_id = NULL', ['issue_id IN (?)', @issues])
                   when 'reassign'
                     reassign_to = @project.issues.find_by_id(params[:reassign_to_id])
                     if reassign_to.nil?
                       flash.now[:error] = l(:error_issue_not_found_in_project)
                       return
                     else
                       TimeEntry.update_all("issue_id = #{reassign_to.id}", ['issue_id IN (?)', @issues])
                     end
                   else
                     # display the destroy form if it's a user request
                     return unless api_request?
                   end
                 end
                 @issues.each do |issue|
                   begin
                     issue.reload.destroy
                   rescue ::ActiveRecord::RecordNotFound # raised by #reload if issue no longer exists
                     # nothing to do, issue was already deleted (eg. by a parent)
                   end
                 end
                 respond_to do |format|
                   format.html { redirect_back_or_default(:action => 'index', :project_id => @project) }
                   format.api  { head :ok }
                 end
               end
             private
               def find_issue
                 # Issue.visible.find(...) can not be used to redirect user to the login form
                 # if the issue actually exists but requires authentication
                 @issue = Issue.find(params[:id], :include => [:project, :tracker, :status, :author, :priority, :category])
                 unless @issue.visible?
                   deny_access
                   return
                 end
                 @project = @issue.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_project
                 project_id = params[:project_id] || (params[:issue] && params[:issue][:project_id])
                 @project = Project.find(project_id)
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def retrieve_previous_and_next_issue_ids
                 retrieve_query_from_session
                 if @query
                   sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
                   sort_update(@query.sortable_columns, 'issues_index_sort')
                   limit = 500
                   issue_ids = @query.issue_ids(:order => sort_clause, :limit => (limit + 1))
                   if (idx = issue_ids.index(@issue.id)) && idx < limit
                     @prev_issue_id = issue_ids[idx - 1] if idx > 0
                     @next_issue_id = issue_ids[idx + 1] if idx < (issue_ids.size - 1)
                   end
                 end
               end
               # Used by #edit and #update to set some common instance variables
               # from the params
               # TODO: Refactor, not everything in here is needed by #edit
               def update_issue_from_params
                 @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                 @priorities = IssuePriority.active
                 @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                 @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
                 @time_entry.attributes = params[:time_entry]
                 @notes = params[:notes] || (params[:issue].present? ? params[:issue][:notes] : nil)
                 @issue.init_journal(User.current, @notes)
                 @issue.safe_attributes = params[:issue]
               end
               # TODO: Refactor, lots of extra code in here
               # TODO: Changing tracker on an existing issue should not trigger this
               def build_new_issue_from_params
                 if params[:id].blank?
                   @issue = Issue.new
                   @issue.copy_from(params[:copy_from]) if params[:copy_from]
                   @issue.project = @project
                 else
                   @issue = @project.issues.visible.find(params[:id])
                 end
                 @issue.project = @project
                 @issue.author = User.current
                 # Tracker must be set before custom field values
                 @issue.tracker ||= @project.trackers.find((params[:issue] && params[:issue][:tracker_id]) || params[:tracker_id] || :first)
                 if @issue.tracker.nil?
                   render_error l(:error_no_tracker_in_project)
                   return false
                 end
                 @issue.start_date ||= Date.today if Setting.default_issue_start_date_to_creation_date?
                 @issue.safe_attributes = params[:issue]
                 @priorities = IssuePriority.active
                 @allowed_statuses = @issue.new_statuses_allowed_to(User.current, true)
               end
               def check_for_default_issue_status
                 if IssueStatus.default.nil?
                   render_error l(:error_no_default_issue_status)
                   return false
                 end
               end
               def parse_params_for_bulk_issue_attributes(params)
                 attributes = (params[:issue] || {}).reject {|k,v| v.blank?}
                 attributes.keys.each {|k| attributes[k] = '' if attributes[k] == 'none'}
                 attributes[:custom_field_values].reject! {|k,v| v.blank?} if attributes[:custom_field_values]
                 attributes
               end
             end

app/views/context_menus/issues.html.erb +1 -1

             <ul>
               <%= call_hook(:view_issues_context_menu_start, {:issues => @issues, :can => @can, :back => @back }) %>
             <% if !@issue.nil? -%>
               <li><%= context_menu_link l(:button_edit), {:controller => 'issues', :action => 'edit', :id => @issue},
                       :class => 'icon-edit', :disabled => !@can[:edit] %></li>
             <% else %>
               <li><%= context_menu_link l(:button_edit), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id)},
                       :class => 'icon-edit', :disabled => !@can[:edit] %></li>
             <% end %>
               <% if @allowed_statuses.present? %>
               <li class="folder">
                 <a href="#" class="submenu" onclick="return false;"><%= l(:field_status) %></a>
                 <ul>
                 <% @statuses.each do |s| -%>
                     <li><%= context_menu_link h(s.name), {:controller => 'issues', :action => 'bulk_update', :ids => @issues.collect(&:id), :issue => {:status_id => s}, :back_url => @back}, :method => :post,
                                               :selected => (@issue && s == @issue.status), :disabled => !(@can[:update] && @allowed_statuses.include?(s)) %></li>
                 <% end -%>
                 </ul>
               </li>
               <% end %>
               <% unless @trackers.nil? %>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_tracker) %></a>
                 <ul>
                 <% @trackers.each do |t| -%>
                     <li><%= context_menu_link h(t.name), {:controller => 'issues', :action => 'bulk_update', :ids => @issues.collect(&:id), :issue => {'tracker_id' => t}, :back_url => @back}, :method => :post,
                                               :selected => (@issue && t == @issue.tracker), :disabled => !@can[:edit] %></li>
                 <% end -%>
                 </ul>
               </li>
               <% end %>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_priority) %></a>
                 <ul>
                 <% @priorities.each do |p| -%>
                     <li><%= context_menu_link h(p.name), {:controller => 'issues', :action => 'bulk_update', :ids => @issues.collect(&:id), :issue => {'priority_id' => p}, :back_url => @back}, :method => :post,
                                               :selected => (@issue && p == @issue.priority), :disabled => (!@can[:edit] || @issues.detect {|i| !i.leaf?}) %></li>
                 <% end -%>
                 </ul>
               </li>
               <% #TODO: allow editing versions when multiple projects %>
               <% unless @project.nil? || @project.shared_versions.open.empty? -%>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_fixed_version) %></a>
                 <ul>
                 <% @project.shared_versions.open.sort.each do |v| -%>
                     <li><%= context_menu_link format_version_name(v), {:controller => 'issues', :action => 'bulk_update', :ids => @issues.collect(&:id), :issue => {'fixed_version_id' => v}, :back_url => @back}, :method => :post,
                                               :selected => (@issue && v == @issue.fixed_version), :disabled => !@can[:update] %></li>
                 <% end -%>
                     <li><%= context_menu_link l(:label_none), {:controller => 'issues', :action => 'bulk_update', :ids => @issues.collect(&:id), :issue => {'fixed_version_id' => 'none'}, :back_url => @back}, :method => :post,
                                               :selected => (@issue && @issue.fixed_version.nil?), :disabled => !@can[:update] %></li>
                 </ul>
               </li>
               <% end %>
               <% if @assignables.present? -%>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_assigned_to) %></a>
                 <ul>
                 <% @assignables.each do |u| -%>
                     <li><%= context_menu_link h(u.name), {:controller => 'issues', :action => 'bulk_update', :ids => @issues.collect(&:id), :issue => {'assigned_to_id' => u}, :back_url => @back}, :method => :post,
                                               :selected => (@issue && u == @issue.assigned_to), :disabled => !@can[:update] %></li>
                 <% end -%>
                     <li><%= context_menu_link l(:label_nobody), {:controller => 'issues', :action => 'bulk_update', :ids => @issues.collect(&:id), :issue => {'assigned_to_id' => 'none'}, :back_url => @back}, :method => :post,
                                               :selected => (@issue && @issue.assigned_to.nil?), :disabled => !@can[:update] %></li>
                 </ul>
               </li>
               <% end %>
               <% unless @project.nil? || @project.issue_categories.empty? -%>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_category) %></a>
                 <ul>
                 <% @project.issue_categories.each do |u| -%>
                     <li><%= context_menu_link h(u.name), {:controller => 'issues', :action => 'bulk_update', :ids => @issues.collect(&:id), :issue => {'category_id' => u}, :back_url => @back}, :method => :post,
                                               :selected => (@issue && u == @issue.category), :disabled => !@can[:update] %></li>
                 <% end -%>
                     <li><%= context_menu_link l(:label_none), {:controller => 'issues', :action => 'bulk_update', :ids => @issues.collect(&:id), :issue => {'category_id' => 'none'}, :back_url => @back}, :method => :post,
                                               :selected => (@issue && @issue.category.nil?), :disabled => !@can[:update] %></li>
                 </ul>
               </li>
               <% end -%>
               <% if Issue.use_field_for_done_ratio? %>
               <li class="folder">
                 <a href="#" class="submenu"><%= l(:field_done_ratio) %></a>
                 <ul>
                 <% (0..10).map{|x|x*10}.each do |p| -%>
                     <li><%= context_menu_link "#{p}%", {:controller => 'issues', :action => 'bulk_update', :ids => @issues.collect(&:id), :issue => {'done_ratio' => p}, :back_url => @back}, :method => :post,
                                                   :selected => (@issue && p == @issue.done_ratio), :disabled => (!@can[:edit] || @issues.detect {|i| !i.leaf?}) %></li>
                 <% end -%>
                 </ul>
               </li>
               <% end %>
             <% if !@issue.nil? %>
               <% if @can[:log_time] -%>
               <li><%= context_menu_link l(:button_log_time), {:controller => 'timelog', :action => 'new', :issue_id => @issue},
                       :class => 'icon-time-add' %></li>
               <% end %>
               <% if User.current.logged? %>
               <li><%= watcher_link(@issue, User.current) %></li>
               <% end %>
             <% end %>
             <% if @issue.present? %>
               <li><%= context_menu_link l(:button_duplicate), {:controller => 'issues', :action => 'new', :project_id => @project, :copy_from => @issue},
                       :class => 'icon-duplicate', :disabled => !@can[:copy] %></li>
             <% end %>
-              <li><%= context_menu_link l(:button_copy), new_issue_move_path(:ids => @issues.collect(&:id), :copy_options => {:copy => 't'}),
+              <li><%= context_menu_link l(:button_copy), {:controller => 'issues', :action => 'bulk_edit', :ids => @issues.collect(&:id), :copy => '1'},
                                       :class => 'icon-copy', :disabled => !@can[:move]  %></li>
               <li><%= context_menu_link l(:button_delete), issues_path(:ids => @issues.collect(&:id), :back_url => @back),
                                         :method => :delete, :confirm => issues_destroy_confirmation_message(@issues), :class => 'icon-del', :disabled => !@can[:delete] %></li>
               <%= call_hook(:view_issues_context_menu_end, {:issues => @issues, :can => @can, :back => @back }) %>
             </ul>

app/views/issues/_action_menu.html.erb +1 -1

             <div class="contextual">
             <%= link_to_if_authorized(l(:button_update), {:controller => 'issues', :action => 'edit', :id => @issue }, :onclick => 'showAndScrollTo("update", "notes"); return false;', :class => 'icon icon-edit', :accesskey => accesskey(:edit)) %>
             <%= link_to_if_authorized l(:button_log_time), {:controller => 'timelog', :action => 'new', :issue_id => @issue}, :class => 'icon icon-time-add' %>
             <%= watcher_tag(@issue, User.current) %>
             <%= link_to_if_authorized l(:button_duplicate), {:controller => 'issues', :action => 'new', :project_id => @project, :copy_from => @issue }, :class => 'icon icon-duplicate' %>
-            <%= link_to_if_authorized l(:button_copy), {:controller => 'issue_moves', :action => 'new', :id => @issue, :copy_options => {:copy => 't'}}, :class => 'icon icon-copy' %>
+            <%= link_to_if_authorized l(:button_copy), {:controller => 'issues', :action => 'bulk_edit', :id => @issue, :copy => '1'}, :class => 'icon icon-copy' %>
             <%= link_to l(:button_delete), issue_path(@issue), :confirm => issues_destroy_confirmation_message(@issue), :method => :delete, :class => 'icon icon-del' if User.current.allowed_to?(:delete_issues, @project) %>
             </div>

app/views/issues/bulk_edit.html.erb +6 -2

-            <h2><%= l(:label_bulk_edit_selected_issues) %></h2>
+            <h2><%= @copy ? l(:button_copy) : l(:label_bulk_edit_selected_issues) %></h2>
             <ul><%= @issues.collect {|i|
                         content_tag('li',
                                     link_to(h("#{i.tracker} ##{i.id}"),
                                             { :action => 'show', :id => i }
                                         ) + h(": #{i.subject}"))
                      }.join("\n").html_safe %></ul>
             <% form_tag({:action => 'bulk_update'}, :id => 'bulk_edit_form') do %>
             <%= @issues.collect {|i| hidden_field_tag('ids[]', i.id)}.join("\n").html_safe %>
             <div class="box tabular">
             <fieldset class="attributes">
             <legend><%= l(:label_change_properties) %></legend>
             <div class="splitcontentleft">
             <% if @allowed_projects.present? %>
             <p>
               <label for="issue_project_id"><%= l(:field_project) %></label>
               <%= select_tag('issue[project_id]', "<option value=\"\">#{l(:label_no_change_option)}</option>" + project_tree_options_for_select(@allowed_projects, :selected => @target_project)) %>
             </p>
             <%= observe_field :issue_project_id, :url => {:action => 'bulk_edit'},
                                                  :update => 'content',
                                                  :with => "Form.serialize('bulk_edit_form')" %>
             <% end %>
             <p>
               <label for="issue_tracker_id"><%= l(:field_tracker) %></label>
               <%= select_tag('issue[tracker_id]', "<option value=\"\">#{l(:label_no_change_option)}</option>" + options_from_collection_for_select(@trackers, :id, :name)) %>
             </p>
             <% if @available_statuses.any? %>
             <p>
               <label for='issue_status_id'><%= l(:field_status) %></label>
               <%= select_tag('issue[status_id]', "<option value=\"\">#{l(:label_no_change_option)}</option>" + options_from_collection_for_select(@available_statuses, :id, :name)) %>
             </p>
             <% end %>
             <p>
               <label for='issue_priority_id'><%= l(:field_priority) %></label>
               <%= select_tag('issue[priority_id]', "<option value=\"\">#{l(:label_no_change_option)}</option>" + options_from_collection_for_select(IssuePriority.active, :id, :name)) %>
             </p>
             <p>
               <label for='issue_assigned_to_id'><%= l(:field_assigned_to) %></label>
               <%= select_tag('issue[assigned_to_id]', content_tag('option', l(:label_no_change_option), :value => '') +
                                              content_tag('option', l(:label_nobody), :value => 'none') +
                                              principals_options_for_select(@assignables)) %>
             </p>
             <% if @project %>
             <p>
               <label for='issue_category_id'><%= l(:field_category) %></label>
               <%= select_tag('issue[category_id]', content_tag('option', l(:label_no_change_option), :value => '') +
                                             content_tag('option', l(:label_none), :value => 'none') +
                                             options_from_collection_for_select(@project.issue_categories, :id, :name)) %>
             </p>
             <% end %>
             <% #TODO: allow editing versions when multiple projects %>
             <% if @project %>
             <p>
               <label for='issue_fixed_version_id'><%= l(:field_fixed_version) %></label>
               <%= select_tag('issue[fixed_version_id]', content_tag('option', l(:label_no_change_option), :value => '') +
                                                content_tag('option', l(:label_none), :value => 'none') +
                                                version_options_for_select(@project.shared_versions.open.sort)) %>
             </p>
             <% end %>
             <% @custom_fields.each do |custom_field| %>
               <p><label><%= h(custom_field.name) %></label> <%= custom_field_tag_for_bulk_edit('issue', custom_field, @projects) %></p>
             <% end %>
             <%= call_hook(:view_issues_bulk_edit_details_bottom, { :issues => @issues }) %>
             </div>
             <div class="splitcontentright">
             <% if @project && User.current.allowed_to?(:manage_subtasks, @project) %>
             <p>
               <label for='issue_parent_issue_id'><%= l(:field_parent_issue) %></label>
               <%= text_field_tag 'issue[parent_issue_id]', '', :size => 10 %>
             </p>
             <div id="parent_issue_candidates" class="autocomplete"></div>
             <%= javascript_tag "observeParentIssueField('#{auto_complete_issues_path(:project_id => @project) }')" %>
             <% end %>
             <p>
               <label for='issue_start_date'><%= l(:field_start_date) %></label>
               <%= text_field_tag 'issue[start_date]', '', :size => 10 %><%= calendar_for('issue_start_date') %>
             </p>
             <p>
               <label for='issue_due_date'><%= l(:field_due_date) %></label>
               <%= text_field_tag 'issue[due_date]', '', :size => 10 %><%= calendar_for('issue_due_date') %>
             </p>
             <% if Issue.use_field_for_done_ratio? %>
             <p>
               <label for='issue_done_ratio'><%= l(:field_done_ratio) %></label>
               <%= select_tag 'issue[done_ratio]', options_for_select([[l(:label_no_change_option), '']] + (0..10).to_a.collect {|r| ["#{r*10} %", r*10] }) %>
             </p>
             <% end %>
             </div>
             </fieldset>
             <fieldset><legend><%= l(:field_notes) %></legend>
             <%= text_area_tag 'notes', @notes, :cols => 60, :rows => 10, :class => 'wiki-edit' %>
             <%= wikitoolbar_for 'notes' %>
             </fieldset>
             </div>
             <p>
-            	<% if @target_project %>
+            	<% if @copy %>
+            	  <%= hidden_field_tag 'copy', '1' %>
+            	  <%= submit_tag l(:button_copy) %>
+            	  <%= submit_tag l(:button_copy_and_follow), :name => 'follow' %>
+            	<% elsif @target_project %>
             	  <%= submit_tag l(:button_move) %>
             	  <%= submit_tag l(:button_move_and_follow), :name => 'follow' %>
             	<% else %>
             	  <%= submit_tag l(:button_submit) %>
             	<% end %>
             </p>
             <% end %>

config/routes.rb 0 -3

             ActionController::Routing::Routes.draw do |map|
               # Add your own custom routes here.
               # The priority is based upon order of creation: first created -> highest priority.
               # Here's a sample route:
               # map.connect 'products/:id', :controller => 'catalog', :action => 'view'
               # Keep in mind you can assign values other than :controller and :action
               map.home '', :controller => 'welcome', :conditions => {:method => :get}
               map.signin 'login', :controller => 'account', :action => 'login',
                          :conditions => {:method => [:get, :post]}
               map.signout 'logout', :controller => 'account', :action => 'logout',
                           :conditions => {:method => :get}
               map.connect 'account/register', :controller => 'account', :action => 'register',
                           :conditions => {:method => [:get, :post]}
               map.connect 'account/lost_password', :controller => 'account', :action => 'lost_password',
                           :conditions => {:method => [:get, :post]}
               map.connect 'account/activate', :controller => 'account', :action => 'activate',
                           :conditions => {:method => :get}
               map.connect 'projects/:id/wiki', :controller => 'wikis',
                           :action => 'edit', :conditions => {:method => :post}
               map.connect 'projects/:id/wiki/destroy', :controller => 'wikis',
                           :action => 'destroy', :conditions => {:method => [:get, :post]}
               map.with_options :controller => 'messages' do |messages_routes|
                 messages_routes.with_options :conditions => {:method => :get} do |messages_views|
                   messages_views.connect 'boards/:board_id/topics/new', :action => 'new'
                   messages_views.connect 'boards/:board_id/topics/:id', :action => 'show'
                   messages_views.connect 'boards/:board_id/topics/:id/edit', :action => 'edit'
                 end
                 messages_routes.with_options :conditions => {:method => :post} do |messages_actions|
                   messages_actions.connect 'boards/:board_id/topics/new', :action => 'new'
                   messages_actions.connect 'boards/:board_id/topics/preview', :action => 'preview'
                   messages_actions.connect 'boards/:board_id/topics/quote/:id', :action => 'quote'
                   messages_actions.connect 'boards/:board_id/topics/:id/replies', :action => 'reply'
                   messages_actions.connect 'boards/:board_id/topics/:id/edit', :action => 'edit'
                   messages_actions.connect 'boards/:board_id/topics/:id/destroy', :action => 'destroy'
                 end
               end
-              map.resources :issue_moves, :only => [:new, :create],
-                            :path_prefix => '/issues', :as => 'move'
               # Misc issue routes. TODO: move into resources
               map.auto_complete_issues '/issues/auto_complete', :controller => 'auto_completes',
                                        :action => 'issues', :conditions => { :method => :get }
               # TODO: would look nicer as /issues/:id/preview
               map.preview_issue '/issues/preview/:id', :controller => 'previews',
                                 :action => 'issue'
               map.issues_context_menu '/issues/context_menu',
                                       :controller => 'context_menus', :action => 'issues'
               map.issue_changes '/issues/changes', :controller => 'journals', :action => 'index'
               map.quoted_issue '/issues/:id/quoted', :controller => 'journals', :action => 'new',
                                :id => /\d+/, :conditions => { :method => :post }
               map.connect '/journals/diff/:id', :controller => 'journals', :action => 'diff',
                           :id => /\d+/, :conditions => { :method => :get }
               map.connect '/journals/edit/:id', :controller => 'journals', :action => 'edit',
                           :id => /\d+/, :conditions => { :method => [:get, :post] }
               map.with_options :controller => 'gantts', :action => 'show' do |gantts_routes|
                 gantts_routes.connect '/projects/:project_id/issues/gantt'
                 gantts_routes.connect '/projects/:project_id/issues/gantt.:format'
                 gantts_routes.connect '/issues/gantt.:format'
               end
               map.with_options :controller => 'calendars', :action => 'show' do |calendars_routes|
                 calendars_routes.connect '/projects/:project_id/issues/calendar'
                 calendars_routes.connect '/issues/calendar'
               end
               map.with_options :controller => 'reports', :conditions => {:method => :get} do |reports|
                 reports.connect 'projects/:id/issues/report', :action => 'issue_report'
                 reports.connect 'projects/:id/issues/report/:detail', :action => 'issue_report_details'
               end
               map.connect 'my/account', :controller => 'my', :action => 'account',
                           :conditions => {:method => [:get, :post]}
               map.connect 'my/page', :controller => 'my', :action => 'page',
                           :conditions => {:method => :get}
               # Redirects to my/page
               map.connect 'my', :controller => 'my', :action => 'index',
                           :conditions => {:method => :get}
               map.connect 'my/reset_rss_key', :controller => 'my', :action => 'reset_rss_key',
                           :conditions => {:method => :post}
               map.connect 'my/reset_api_key', :controller => 'my', :action => 'reset_api_key',
                           :conditions => {:method => :post}
               map.connect 'my/password', :controller => 'my', :action => 'password',
                           :conditions => {:method => [:get, :post]}
               map.connect 'my/page_layout', :controller => 'my', :action => 'page_layout',
                           :conditions => {:method => :get}
               map.connect 'my/add_block', :controller => 'my', :action => 'add_block',
                           :conditions => {:method => :post}
               map.connect 'my/remove_block', :controller => 'my', :action => 'remove_block',
                           :conditions => {:method => :post}
               map.connect 'my/order_blocks', :controller => 'my', :action => 'order_blocks',
                           :conditions => {:method => :post}
               map.connect 'projects/:id/members/new', :controller => 'members',
                           :action => 'new', :conditions => { :method => :post }
               map.connect 'members/edit/:id', :controller => 'members',
                           :action => 'edit', :id => /\d+/, :conditions => { :method => :post }
               map.connect 'members/destroy/:id', :controller => 'members',
                           :action => 'destroy', :id => /\d+/, :conditions => { :method => :post }
               map.connect 'members/autocomplete_for_member/:id', :controller => 'members',
                           :action => 'autocomplete_for_member', :conditions => { :method => :post }
               map.with_options :controller => 'users' do |users|
                 users.user_membership 'users/:id/memberships/:membership_id',
                                       :action => 'edit_membership',
                                       :conditions => {:method => :put}
                 users.connect 'users/:id/memberships/:membership_id',
                               :action => 'destroy_membership',
                               :conditions => {:method => :delete}
                 users.user_memberships 'users/:id/memberships',
                                        :action => 'edit_membership',
                                        :conditions => {:method => :post}
               end
               map.resources :users
               # For nice "roadmap" in the url for the index action
               map.connect 'projects/:project_id/roadmap', :controller => 'versions', :action => 'index'
               map.connect 'news', :controller => 'news', :action => 'index'
               map.connect 'news.:format', :controller => 'news', :action => 'index'
               map.preview_news '/news/preview', :controller => 'previews', :action => 'news'
               map.connect 'news/:id/comments', :controller => 'comments',
                           :action => 'create', :conditions => {:method => :post}
               map.connect 'news/:id/comments/:comment_id', :controller => 'comments',
                           :action => 'destroy', :conditions => {:method => :delete}
               map.connect 'watchers/new', :controller=> 'watchers', :action => 'new',
                           :conditions => {:method => [:get, :post]}
               map.connect 'watchers/destroy', :controller=> 'watchers', :action => 'destroy',
                           :conditions => {:method => :post}
               map.connect 'watchers/watch', :controller=> 'watchers', :action => 'watch',
                           :conditions => {:method => :post}
               map.connect 'watchers/unwatch', :controller=> 'watchers', :action => 'unwatch',
                           :conditions => {:method => :post}
               # TODO: port to be part of the resources route(s)
               map.with_options :conditions => {:method => :get} do |project_views|
                 project_views.connect 'projects/:id/settings/:tab',
                                       :controller => 'projects', :action => 'settings'
                 project_views.connect 'projects/:project_id/issues/:copy_from/copy',
                                       :controller => 'issues', :action => 'new'
               end
               map.resources :projects, :member => {
                 :copy => [:get, :post],
                 :settings => :get,
                 :modules => :post,
                 :archive => :post,
                 :unarchive => :post
               } do |project|
                 project.resource :project_enumerations, :as => 'enumerations',
                                  :only => [:update, :destroy]
                 # issue form update
                 project.issue_form 'issues/new', :controller => 'issues',
                                    :action => 'new', :conditions => {:method => [:post, :put]}
                 project.resources :issues, :only => [:index, :new, :create] do |issues|
                   issues.resources :time_entries, :controller => 'timelog',
                                    :collection => {:report => :get}
                 end
                 project.resources :files, :only => [:index, :new, :create]
                 project.resources :versions, :shallow => true,
                                   :collection => {:close_completed => :put},
                                   :member => {:status_by => :post}
                 project.resources :news, :shallow => true
                 project.resources :time_entries, :controller => 'timelog',
                                   :path_prefix => 'projects/:project_id',
                                   :collection => {:report => :get}
                 project.resources :queries, :only => [:new, :create]
                 project.resources :issue_categories, :shallow => true
                 project.resources :documents, :shallow => true, :member => {:add_attachment => :post}
                 project.resources :boards
                 project.wiki_start_page 'wiki', :controller => 'wiki', :action => 'show', :conditions => {:method => :get}
                 project.wiki_index 'wiki/index', :controller => 'wiki', :action => 'index', :conditions => {:method => :get}
                 project.wiki_diff 'wiki/:id/diff/:version', :controller => 'wiki', :action => 'diff', :version => nil
                 project.wiki_diff 'wiki/:id/diff/:version/vs/:version_from', :controller => 'wiki', :action => 'diff'
                 project.wiki_annotate 'wiki/:id/annotate/:version', :controller => 'wiki', :action => 'annotate'
                 project.resources :wiki, :except => [:new, :create], :member => {
                   :rename => [:get, :post],
                   :history => :get,
                   :preview => :any,
                   :protect => :post,
                   :add_attachment => :post
                 }, :collection => {
                   :export => :get,
                   :date_index => :get
                 }
               end
               map.resources :queries, :except => [:show]
               map.resources :issues,
                             :collection => {:bulk_edit => [:get, :post], :bulk_update => :post} do |issues|
                 issues.resources :time_entries, :controller => 'timelog',
                                  :collection => {:report => :get}
                 issues.resources :relations, :shallow => true,
                                  :controller => 'issue_relations',
                                  :only => [:index, :show, :create, :destroy]
               end
               # Bulk deletion
               map.connect '/issues', :controller => 'issues', :action => 'destroy',
                           :conditions => {:method => :delete}
               map.connect '/time_entries/destroy',
                           :controller => 'timelog', :action => 'destroy',
                           :conditions => { :method => :delete }
               map.time_entries_context_menu '/time_entries/context_menu',
                                :controller => 'context_menus', :action => 'time_entries'
               map.resources :time_entries, :controller => 'timelog',
                             :collection => {:report => :get, :bulk_edit => :get, :bulk_update => :post}
               map.with_options :controller => 'activities', :action => 'index',
                                :conditions => {:method => :get} do |activity|
                 activity.connect 'projects/:id/activity'
                 activity.connect 'projects/:id/activity.:format'
                 activity.connect 'activity', :id => nil
                 activity.connect 'activity.:format', :id => nil
               end
               map.with_options :controller => 'repositories' do |repositories|
                 repositories.with_options :conditions => {:method => :get} do |repository_views|
                   repository_views.connect 'projects/:id/repository',
                                            :action => 'show'
                   repository_views.connect 'projects/:id/repository/statistics',
                                            :action => 'stats'
                   repository_views.connect 'projects/:id/repository/revisions',
                                            :action => 'revisions'
                   repository_views.connect 'projects/:id/repository/revisions.:format',
                                            :action => 'revisions'
                   repository_views.connect 'projects/:id/repository/revisions/:rev',
                                            :action => 'revision'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/diff',
                                            :action => 'diff'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/diff.:format',
                                            :action => 'diff'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/raw/*path',
                                            :action => 'entry',
                                            :format => 'raw',
                                            :requirements => { :rev => /[a-z0-9\.\-_]+/ }
                   repository_views.connect 'projects/:id/repository/revisions/:rev/:action/*path',
                                            :requirements => { :rev => /[a-z0-9\.\-_]+/ }
                   repository_views.connect 'projects/:id/repository/raw/*path',
                                            :action => 'entry', :format => 'raw'
                   repository_views.connect 'projects/:id/repository/browse/*path',
                                            :action => 'browse'
                   repository_views.connect 'projects/:id/repository/entry/*path',
                                            :action => 'entry'
                   repository_views.connect 'projects/:id/repository/changes/*path',
                                            :action => 'changes'
                   repository_views.connect 'projects/:id/repository/annotate/*path',
                                            :action => 'annotate'
                   repository_views.connect 'projects/:id/repository/diff/*path',
                                            :action => 'diff'
                   repository_views.connect 'projects/:id/repository/show/*path',
                                            :action => 'show'
                   repository_views.connect 'projects/:id/repository/graph',
                                            :action => 'graph'
                 end
                 repositories.connect 'projects/:id/repository/revision',
                                      :action => 'revision',
                                      :conditions => {:method => [:get, :post]}
                 repositories.connect 'projects/:id/repository/committers',
                                      :action => 'committers',
                                      :conditions => {:method => [:get, :post]}
                 repositories.connect 'projects/:id/repository/edit',
                                      :action => 'edit',
                                      :conditions => {:method => [:get, :post]}
                 repositories.connect 'projects/:id/repository/destroy',
                                      :action => 'destroy',
                                      :conditions => {:method => :post}
               end
               # additional routes for having the file name at the end of url
               map.connect 'attachments/:id/:filename', :controller => 'attachments',
                           :action => 'show', :id => /\d+/, :filename => /.*/,
                           :conditions => {:method => :get}
               map.connect 'attachments/download/:id/:filename', :controller => 'attachments',
                           :action => 'download', :id => /\d+/, :filename => /.*/,
                           :conditions => {:method => :get}
               map.connect 'attachments/download/:id', :controller => 'attachments',
                           :action => 'download', :id => /\d+/,
                           :conditions => {:method => :get}
               map.resources :attachments, :only => [:show, :destroy]
               map.resources :groups, :member => {:autocomplete_for_user => :get}
               map.group_users 'groups/:id/users', :controller => 'groups',
                               :action => 'add_users', :id => /\d+/,
                               :conditions => {:method => :post}
               map.group_user  'groups/:id/users/:user_id', :controller => 'groups',
                               :action => 'remove_user', :id => /\d+/,
                               :conditions => {:method => :delete}
               map.connect 'groups/destroy_membership/:id', :controller => 'groups',
                           :action => 'destroy_membership', :id => /\d+/,
                           :conditions => {:method => :post}
               map.connect 'groups/edit_membership/:id', :controller => 'groups',
                           :action => 'edit_membership', :id => /\d+/,
                           :conditions => {:method => :post}
               map.resources :trackers, :except => :show
               map.resources :issue_statuses, :except => :show, :collection => {:update_issue_done_ratio => :post}
               map.resources :custom_fields, :except => :show
               map.resources :roles, :except => :show, :collection => {:permissions => [:get, :post]}
               map.resources :enumerations, :except => :show
               map.connect 'search', :controller => 'search', :action => 'index', :conditions => {:method => :get}
               map.connect 'mail_handler', :controller => 'mail_handler',
                           :action => 'index', :conditions => {:method => :post}
               map.connect 'admin', :controller => 'admin', :action => 'index',
                           :conditions => {:method => :get}
               map.connect 'admin/projects', :controller => 'admin', :action => 'projects',
                           :conditions => {:method => :get}
               map.connect 'admin/plugins', :controller => 'admin', :action => 'plugins',
                           :conditions => {:method => :get}
               map.connect 'admin/info', :controller => 'admin', :action => 'info',
                           :conditions => {:method => :get}
               map.connect 'admin/test_email', :controller => 'admin', :action => 'test_email',
                           :conditions => {:method => :get}
               map.connect 'admin/default_configuration', :controller => 'admin',
                           :action => 'default_configuration', :conditions => {:method => :post}
               # Used by AuthSourcesControllerTest
               # TODO : refactor *AuthSourcesController to remove these routes
               map.connect 'auth_sources', :controller => 'auth_sources',
                           :action => 'index', :conditions => {:method => :get}
               map.connect 'auth_sources/new', :controller => 'auth_sources',
                           :action => 'new', :conditions => {:method => :get}
               map.connect 'auth_sources/create', :controller => 'auth_sources',
                           :action => 'create', :conditions => {:method => :post}
               map.connect 'auth_sources/destroy/:id', :controller => 'auth_sources',
                           :action => 'destroy', :id => /\d+/, :conditions => {:method => :post}
               map.connect 'auth_sources/test_connection/:id', :controller => 'auth_sources',
                           :action => 'test_connection', :conditions => {:method => :get}
               map.connect 'auth_sources/edit/:id', :controller => 'auth_sources',
                           :action => 'edit', :id => /\d+/, :conditions => {:method => :get}
               map.connect 'auth_sources/update/:id', :controller => 'auth_sources',
                           :action => 'update', :id => /\d+/, :conditions => {:method => :post}
               map.connect 'ldap_auth_sources', :controller => 'ldap_auth_sources',
                           :action => 'index', :conditions => {:method => :get}
               map.connect 'ldap_auth_sources/new', :controller => 'ldap_auth_sources',
                           :action => 'new', :conditions => {:method => :get}
               map.connect 'ldap_auth_sources/create', :controller => 'ldap_auth_sources',
                           :action => 'create', :conditions => {:method => :post}
               map.connect 'ldap_auth_sources/destroy/:id', :controller => 'ldap_auth_sources',
                           :action => 'destroy', :id => /\d+/, :conditions => {:method => :post}
               map.connect 'ldap_auth_sources/test_connection/:id', :controller => 'ldap_auth_sources',
                           :action => 'test_connection', :conditions => {:method => :get}
               map.connect 'ldap_auth_sources/edit/:id', :controller => 'ldap_auth_sources',
                           :action => 'edit', :id => /\d+/, :conditions => {:method => :get}
               map.connect 'ldap_auth_sources/update/:id', :controller => 'ldap_auth_sources',
                           :action => 'update', :id => /\d+/, :conditions => {:method => :post}
               map.connect 'workflows', :controller => 'workflows',
                           :action => 'index', :conditions => {:method => :get}
               map.connect 'workflows/edit', :controller => 'workflows',
                           :action => 'edit', :conditions => {:method => [:get, :post]}
               map.connect 'workflows/copy', :controller => 'workflows',
                           :action => 'copy', :conditions => {:method => [:get, :post]}
               map.connect 'settings', :controller => 'settings',
                           :action => 'index', :conditions => {:method => :get}
               map.connect 'settings/edit', :controller => 'settings',
                           :action => 'edit', :conditions => {:method => [:get, :post]}
               map.connect 'settings/plugin/:id', :controller => 'settings',
                           :action => 'plugin', :conditions => {:method => [:get, :post]}
               map.with_options :controller => 'sys' do |sys|
                 sys.connect 'sys/projects.:format',
                             :action => 'projects',
                             :conditions => {:method => :get}
                 sys.connect 'sys/projects/:id/repository.:format',
                             :action => 'create_project_repository',
                             :conditions => {:method => :post}
                 sys.connect 'sys/fetch_changesets',
                             :action => 'fetch_changesets',
                             :conditions => {:method => :get}
               end
               map.connect 'robots.txt', :controller => 'welcome',
                           :action => 'robots', :conditions => {:method => :get}
               # Used for OpenID
               map.root :controller => 'account', :action => 'login'
             end

lib/redmine.rb +1 -1

             require 'redmine/access_control'
             require 'redmine/menu_manager'
             require 'redmine/activity'
             require 'redmine/search'
             require 'redmine/custom_field_format'
             require 'redmine/mime_type'
             require 'redmine/core_ext'
             require 'redmine/themes'
             require 'redmine/hook'
             require 'redmine/plugin'
             require 'redmine/notifiable'
             require 'redmine/wiki_formatting'
             require 'redmine/scm/base'
             begin
               require_library_or_gem 'RMagick' unless Object.const_defined?(:Magick)
             rescue LoadError
               # RMagick is not available
             end
             if RUBY_VERSION < '1.9'
               require 'faster_csv'
             else
               require 'csv'
               FCSV = CSV
             end
             Redmine::Scm::Base.add "Subversion"
             Redmine::Scm::Base.add "Darcs"
             Redmine::Scm::Base.add "Mercurial"
             Redmine::Scm::Base.add "Cvs"
             Redmine::Scm::Base.add "Bazaar"
             Redmine::Scm::Base.add "Git"
             Redmine::Scm::Base.add "Filesystem"
             Redmine::CustomFieldFormat.map do |fields|
               fields.register Redmine::CustomFieldFormat.new('string', :label => :label_string, :order => 1)
               fields.register Redmine::CustomFieldFormat.new('text', :label => :label_text, :order => 2)
               fields.register Redmine::CustomFieldFormat.new('int', :label => :label_integer, :order => 3)
               fields.register Redmine::CustomFieldFormat.new('float', :label => :label_float, :order => 4)
               fields.register Redmine::CustomFieldFormat.new('list', :label => :label_list, :order => 5)
               fields.register Redmine::CustomFieldFormat.new('date', :label => :label_date, :order => 6)
               fields.register Redmine::CustomFieldFormat.new('bool', :label => :label_boolean, :order => 7)
               fields.register Redmine::CustomFieldFormat.new('user', :label => :label_user, :only => %w(Issue TimeEntry Version Project), :edit_as => 'list', :order => 8)
               fields.register Redmine::CustomFieldFormat.new('version', :label => :label_version, :only => %w(Issue TimeEntry Version Project), :edit_as => 'list', :order => 9)
             end
             # Permissions
             Redmine::AccessControl.map do |map|
               map.permission :view_project, {:projects => [:show], :activities => [:index]}, :public => true
               map.permission :search_project, {:search => :index}, :public => true
               map.permission :add_project, {:projects => [:new, :create]}, :require => :loggedin
               map.permission :edit_project, {:projects => [:settings, :edit, :update]}, :require => :member
               map.permission :select_project_modules, {:projects => :modules}, :require => :member
               map.permission :manage_members, {:projects => :settings, :members => [:new, :edit, :destroy, :autocomplete_for_member]}, :require => :member
               map.permission :manage_versions, {:projects => :settings, :versions => [:new, :create, :edit, :update, :close_completed, :destroy]}, :require => :member
               map.permission :add_subprojects, {:projects => [:new, :create]}, :require => :member
               map.project_module :issue_tracking do |map|
                 # Issue categories
                 map.permission :manage_categories, {:projects => :settings, :issue_categories => [:index, :show, :new, :create, :edit, :update, :destroy]}, :require => :member
                 # Issues
                 map.permission :view_issues, {:issues => [:index, :show],
                                               :auto_complete => [:issues],
                                               :context_menus => [:issues],
                                               :versions => [:index, :show, :status_by],
                                               :journals => [:index, :diff],
                                               :queries => :index,
                                               :reports => [:issue_report, :issue_report_details]}
                 map.permission :add_issues, {:issues => [:new, :create, :update_form]}
                 map.permission :edit_issues, {:issues => [:edit, :update, :bulk_edit, :bulk_update, :update_form], :journals => [:new]}
                 map.permission :manage_issue_relations, {:issue_relations => [:index, :show, :create, :destroy]}
                 map.permission :manage_subtasks, {}
                 map.permission :set_issues_private, {}
                 map.permission :set_own_issues_private, {}, :require => :loggedin
                 map.permission :add_issue_notes, {:issues => [:edit, :update], :journals => [:new]}
                 map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin
-                map.permission :move_issues, {:issue_moves => [:new, :create]}, :require => :loggedin
+                map.permission :move_issues, {:issues => [:bulk_edit, :bulk_update]}, :require => :loggedin
                 map.permission :delete_issues, {:issues => :destroy}, :require => :member
                 # Queries
                 map.permission :manage_public_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :save_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :loggedin
                 # Watchers
                 map.permission :view_issue_watchers, {}
                 map.permission :add_issue_watchers, {:watchers => :new}
                 map.permission :delete_issue_watchers, {:watchers => :destroy}
               end
               map.project_module :time_tracking do |map|
                 map.permission :log_time, {:timelog => [:new, :create]}, :require => :loggedin
                 map.permission :view_time_entries, :timelog => [:index, :report, :show]
                 map.permission :edit_time_entries, {:timelog => [:edit, :update, :destroy, :bulk_edit, :bulk_update]}, :require => :member
                 map.permission :edit_own_time_entries, {:timelog => [:edit, :update, :destroy,:bulk_edit, :bulk_update]}, :require => :loggedin
                 map.permission :manage_project_activities, {:project_enumerations => [:update, :destroy]}, :require => :member
               end
               map.project_module :news do |map|
                 map.permission :manage_news, {:news => [:new, :create, :edit, :update, :destroy], :comments => [:destroy]}, :require => :member
                 map.permission :view_news, {:news => [:index, :show]}, :public => true
                 map.permission :comment_news, {:comments => :create}
               end
               map.project_module :documents do |map|
                 map.permission :manage_documents, {:documents => [:new, :create, :edit, :update, :destroy, :add_attachment]}, :require => :loggedin
                 map.permission :view_documents, :documents => [:index, :show, :download]
               end
               map.project_module :files do |map|
                 map.permission :manage_files, {:files => [:new, :create]}, :require => :loggedin
                 map.permission :view_files, :files => :index, :versions => :download
               end
               map.project_module :wiki do |map|
                 map.permission :manage_wiki, {:wikis => [:edit, :destroy]}, :require => :member
                 map.permission :rename_wiki_pages, {:wiki => :rename}, :require => :member
                 map.permission :delete_wiki_pages, {:wiki => :destroy}, :require => :member
                 map.permission :view_wiki_pages, :wiki => [:index, :show, :special, :date_index]
                 map.permission :export_wiki_pages, :wiki => [:export]
                 map.permission :view_wiki_edits, :wiki => [:history, :diff, :annotate]
                 map.permission :edit_wiki_pages, :wiki => [:edit, :update, :preview, :add_attachment]
                 map.permission :delete_wiki_pages_attachments, {}
                 map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
               end
               map.project_module :repository do |map|
                 map.permission :manage_repository, {:repositories => [:edit, :committers, :destroy]}, :require => :member
                 map.permission :browse_repository, :repositories => [:show, :browse, :entry, :annotate, :changes, :diff, :stats, :graph]
                 map.permission :view_changesets, :repositories => [:show, :revisions, :revision]
                 map.permission :commit_access, {}
               end
               map.project_module :boards do |map|
                 map.permission :manage_boards, {:boards => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :view_messages, {:boards => [:index, :show], :messages => [:show]}, :public => true
                 map.permission :add_messages, {:messages => [:new, :reply, :quote]}
                 map.permission :edit_messages, {:messages => :edit}, :require => :member
                 map.permission :edit_own_messages, {:messages => :edit}, :require => :loggedin
                 map.permission :delete_messages, {:messages => :destroy}, :require => :member
                 map.permission :delete_own_messages, {:messages => :destroy}, :require => :loggedin
               end
               map.project_module :calendar do |map|
                 map.permission :view_calendar, :calendars => [:show, :update]
               end
               map.project_module :gantt do |map|
                 map.permission :view_gantt, :gantts => [:show, :update]
               end
             end
             Redmine::MenuManager.map :top_menu do |menu|
               menu.push :home, :home_path
               menu.push :my_page, { :controller => 'my', :action => 'page' }, :if => Proc.new { User.current.logged? }
               menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural
               menu.push :administration, { :controller => 'admin', :action => 'index' }, :if => Proc.new { User.current.admin? }, :last => true
               menu.push :help, Redmine::Info.help_url, :last => true
             end
             Redmine::MenuManager.map :account_menu do |menu|
               menu.push :login, :signin_path, :if => Proc.new { !User.current.logged? }
               menu.push :register, { :controller => 'account', :action => 'register' }, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
               menu.push :my_account, { :controller => 'my', :action => 'account' }, :if => Proc.new { User.current.logged? }
               menu.push :logout, :signout_path, :if => Proc.new { User.current.logged? }
             end
             Redmine::MenuManager.map :application_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :admin_menu do |menu|
               menu.push :projects, {:controller => 'admin', :action => 'projects'}, :caption => :label_project_plural
               menu.push :users, {:controller => 'users'}, :caption => :label_user_plural
               menu.push :groups, {:controller => 'groups'}, :caption => :label_group_plural
               menu.push :roles, {:controller => 'roles'}, :caption => :label_role_and_permissions
               menu.push :trackers, {:controller => 'trackers'}, :caption => :label_tracker_plural
               menu.push :issue_statuses, {:controller => 'issue_statuses'}, :caption => :label_issue_status_plural,
                         :html => {:class => 'issue_statuses'}
               menu.push :workflows, {:controller => 'workflows', :action => 'edit'}, :caption => :label_workflow
               menu.push :custom_fields, {:controller => 'custom_fields'},  :caption => :label_custom_field_plural,
                         :html => {:class => 'custom_fields'}
               menu.push :enumerations, {:controller => 'enumerations'}
               menu.push :settings, {:controller => 'settings'}
               menu.push :ldap_authentication, {:controller => 'ldap_auth_sources', :action => 'index'},
                         :html => {:class => 'server_authentication'}
               menu.push :plugins, {:controller => 'admin', :action => 'plugins'}, :last => true
               menu.push :info, {:controller => 'admin', :action => 'info'}, :caption => :label_information_plural, :last => true
             end
             Redmine::MenuManager.map :project_menu do |menu|
               menu.push :overview, { :controller => 'projects', :action => 'show' }
               menu.push :activity, { :controller => 'activities', :action => 'index' }
               menu.push :roadmap, { :controller => 'versions', :action => 'index' }, :param => :project_id,
                           :if => Proc.new { |p| p.shared_versions.any? }
               menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
               menu.push :new_issue, { :controller => 'issues', :action => 'new' }, :param => :project_id, :caption => :label_issue_new,
                           :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) }
               menu.push :gantt, { :controller => 'gantts', :action => 'show' }, :param => :project_id, :caption => :label_gantt
               menu.push :calendar, { :controller => 'calendars', :action => 'show' }, :param => :project_id, :caption => :label_calendar
               menu.push :news, { :controller => 'news', :action => 'index' }, :param => :project_id, :caption => :label_news_plural
               menu.push :documents, { :controller => 'documents', :action => 'index' }, :param => :project_id, :caption => :label_document_plural
               menu.push :wiki, { :controller => 'wiki', :action => 'show', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }
               menu.push :boards, { :controller => 'boards', :action => 'index', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.boards.any? }, :caption => :label_board_plural
               menu.push :files, { :controller => 'files', :action => 'index' }, :caption => :label_file_plural, :param => :project_id
               menu.push :repository, { :controller => 'repositories', :action => 'show' },
                           :if => Proc.new { |p| p.repository && !p.repository.new_record? }
               menu.push :settings, { :controller => 'projects', :action => 'settings' }, :last => true
             end
             Redmine::Activity.map do |activity|
               activity.register :issues, :class_name => %w(Issue Journal)
               activity.register :changesets
               activity.register :news
               activity.register :documents, :class_name => %w(Document Attachment)
               activity.register :files, :class_name => 'Attachment'
               activity.register :wiki_edits, :class_name => 'WikiContent::Version', :default => false
               activity.register :messages, :default => false
               activity.register :time_entries, :default => false
             end
             Redmine::Search.map do |search|
               search.register :issues
               search.register :news
               search.register :documents
               search.register :changesets
               search.register :wiki_pages
               search.register :messages
               search.register :projects
             end
             Redmine::WikiFormatting.map do |format|
               format.register :textile, Redmine::WikiFormatting::Textile::Formatter, Redmine::WikiFormatting::Textile::Helper
             end
             ActionView::Template.register_template_handler :rsb, Redmine::Views::ApiTemplateHandler

test/functional/context_menus_controller_test.rb +2 -2

             require File.expand_path('../../test_helper', __FILE__)
             class ContextMenusControllerTest < ActionController::TestCase
               fixtures :projects,
                        :trackers,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :auth_sources,
                        :enabled_modules,
                        :workflows,
                        :journals, :journal_details,
                        :versions,
                        :issues, :issue_statuses, :issue_categories,
                        :users,
                        :enumerations,
                        :time_entries
               def test_context_menu_one_issue
                 @request.session[:user_id] = 2
                 get :issues, :ids => [1]
                 assert_response :success
                 assert_template 'context_menu'
                 assert_tag :tag => 'a', :content => 'Edit',
                                         :attributes => { :href => '/issues/1/edit',
                                                          :class => 'icon-edit' }
                 assert_tag :tag => 'a', :content => 'Closed',
                                         :attributes => { :href => '/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bstatus_id%5D=5',
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Immediate',
                                         :attributes => { :href => '/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bpriority_id%5D=8',
                                                          :class => '' }
                 assert_no_tag :tag => 'a', :content => 'Inactive Priority'
                 # Versions
                 assert_tag :tag => 'a', :content => '2.0',
                                         :attributes => { :href => '/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bfixed_version_id%5D=3',
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'eCookbook Subproject 1 - 2.0',
                                         :attributes => { :href => '/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bfixed_version_id%5D=4',
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Dave Lopper',
                                         :attributes => { :href => '/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bassigned_to_id%5D=3',
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Duplicate',
                                         :attributes => { :href => '/projects/ecookbook/issues/1/copy',
                                                          :class => 'icon-duplicate' }
                 assert_tag :tag => 'a', :content => 'Copy',
-                                        :attributes => { :href => '/issues/move/new?copy_options%5Bcopy%5D=t&amp;ids%5B%5D=1',
+                                        :attributes => { :href => '/issues/bulk_edit?copy=1&amp;ids%5B%5D=1',
                                                          :class => 'icon-copy' }
                 assert_no_tag :tag => 'a', :content => 'Move'
                 assert_tag :tag => 'a', :content => 'Delete',
                                         :attributes => { :href => '/issues?ids%5B%5D=1',
                                                          :class => 'icon-del' }
               end
               def test_context_menu_one_issue_by_anonymous
                 get :issues, :ids => [1]
                 assert_response :success
                 assert_template 'context_menu'
                 assert_tag :tag => 'a', :content => 'Delete',
                                         :attributes => { :href => '#',
                                                          :class => 'icon-del disabled' }
               end
               def test_context_menu_multiple_issues_of_same_project
                 @request.session[:user_id] = 2
                 get :issues, :ids => [1, 2]
                 assert_response :success
                 assert_template 'context_menu'
                 assert_not_nil assigns(:issues)
                 assert_equal [1, 2], assigns(:issues).map(&:id).sort
                 ids = assigns(:issues).map(&:id).map {|i| "ids%5B%5D=#{i}"}.join('&amp;')
                 assert_tag :tag => 'a', :content => 'Edit',
                                         :attributes => { :href => "/issues/bulk_edit?#{ids}",
                                                          :class => 'icon-edit' }
                 assert_tag :tag => 'a', :content => 'Closed',
                                         :attributes => { :href => "/issues/bulk_update?#{ids}&amp;issue%5Bstatus_id%5D=5",
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Immediate',
                                         :attributes => { :href => "/issues/bulk_update?#{ids}&amp;issue%5Bpriority_id%5D=8",
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Dave Lopper',
                                         :attributes => { :href => "/issues/bulk_update?#{ids}&amp;issue%5Bassigned_to_id%5D=3",
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Copy',
-                                        :attributes => { :href => "/issues/move/new?copy_options%5Bcopy%5D=t&amp;#{ids}",
+                                        :attributes => { :href => "/issues/bulk_edit?copy=1&amp;#{ids}",
                                                          :class => 'icon-copy' }
                 assert_no_tag :tag => 'a', :content => 'Move'
                 assert_tag :tag => 'a', :content => 'Delete',
                                         :attributes => { :href => "/issues?#{ids}",
                                                          :class => 'icon-del' }
               end
               def test_context_menu_multiple_issues_of_different_projects
                 @request.session[:user_id] = 2
                 get :issues, :ids => [1, 2, 6]
                 assert_response :success
                 assert_template 'context_menu'
                 assert_not_nil assigns(:issues)
                 assert_equal [1, 2, 6], assigns(:issues).map(&:id).sort
                 ids = assigns(:issues).map(&:id).map {|i| "ids%5B%5D=#{i}"}.join('&amp;')
                 assert_tag :tag => 'a', :content => 'Edit',
                                         :attributes => { :href => "/issues/bulk_edit?#{ids}",
                                                          :class => 'icon-edit' }
                 assert_tag :tag => 'a', :content => 'Closed',
                                         :attributes => { :href => "/issues/bulk_update?#{ids}&amp;issue%5Bstatus_id%5D=5",
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Immediate',
                                         :attributes => { :href => "/issues/bulk_update?#{ids}&amp;issue%5Bpriority_id%5D=8",
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'John Smith',
                                         :attributes => { :href => "/issues/bulk_update?#{ids}&amp;issue%5Bassigned_to_id%5D=2",
                                                          :class => '' }
                 assert_tag :tag => 'a', :content => 'Delete',
                                         :attributes => { :href => "/issues?#{ids}",
                                                          :class => 'icon-del' }
               end
               def test_context_menu_issue_visibility
                 get :issues, :ids => [1, 4]
                 assert_response :success
                 assert_template 'context_menu'
                 assert_equal [1], assigns(:issues).collect(&:id)
               end
               def test_time_entries_context_menu
                 @request.session[:user_id] = 2
                 get :time_entries, :ids => [1, 2]
                 assert_response :success
                 assert_template 'time_entries'
                 assert_tag 'a', :content => 'Edit'
                 assert_no_tag 'a', :content => 'Edit', :attributes => {:class => /disabled/}
               end
               def test_time_entries_context_menu_without_edit_permission
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :edit_time_entries
                 get :time_entries, :ids => [1, 2]
                 assert_response :success
                 assert_template 'time_entries'
                 assert_tag 'a', :content => 'Edit', :attributes => {:class => /disabled/}
               end
             end

test/functional/issues_controller_test.rb +81 0

             # Redmine - project management software
             # Copyright (C) 2006-2011  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__)
             require 'issues_controller'
             class IssuesControllerTest < ActionController::TestCase
               fixtures :projects,
                        :users,
                        :roles,
                        :members,
                        :member_roles,
                        :issues,
                        :issue_statuses,
                        :versions,
                        :trackers,
                        :projects_trackers,
                        :issue_categories,
                        :enabled_modules,
                        :enumerations,
                        :attachments,
                        :workflows,
                        :custom_fields,
                        :custom_values,
                        :custom_fields_projects,
                        :custom_fields_trackers,
                        :time_entries,
                        :journals,
                        :journal_details,
                        :queries
               include Redmine::I18n
               def setup
                 @controller = IssuesController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
               def test_index
                 Setting.default_language = 'en'
                 get :index
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_nil assigns(:project)
                 assert_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
                 # private projects hidden
                 assert_no_tag :tag => 'a', :content => /Issue of a private subproject/
                 assert_no_tag :tag => 'a', :content => /Issue on project 2/
                 # project column
                 assert_tag :tag => 'th', :content => /Project/
               end
               def test_index_should_not_list_issues_when_module_disabled
                 EnabledModule.delete_all("name = 'issue_tracking' AND project_id = 1")
                 get :index
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_nil assigns(:project)
                 assert_no_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
               end
               def test_index_should_list_visible_issues_only
                 get :index, :per_page => 100
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_nil assigns(:issues).detect {|issue| !issue.visible?}
               end
               def test_index_with_project
                 Setting.display_subprojects_issues = 0
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_tag :tag => 'a', :content => /Can't print recipes/
                 assert_no_tag :tag => 'a', :content => /Subproject issue/
               end
               def test_index_with_project_and_subprojects
                 Setting.display_subprojects_issues = 1
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
                 assert_no_tag :tag => 'a', :content => /Issue of a private subproject/
               end
               def test_index_with_project_and_subprojects_should_show_private_subprojects
                 @request.session[:user_id] = 2
                 Setting.display_subprojects_issues = 1
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
                 assert_tag :tag => 'a', :content => /Issue of a private subproject/
               end
               def test_index_with_project_and_default_filter
                 get :index, :project_id => 1, :set_filter => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 query = assigns(:query)
                 assert_not_nil query
                 # default filter
                 assert_equal({'status_id' => {:operator => 'o', :values => ['']}}, query.filters)
               end
               def test_index_with_project_and_filter
                 get :index, :project_id => 1, :set_filter => 1,
                   :f => ['tracker_id'],
                   :op => {'tracker_id' => '='},
                   :v => {'tracker_id' => ['1']}
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 query = assigns(:query)
                 assert_not_nil query
                 assert_equal({'tracker_id' => {:operator => '=', :values => ['1']}}, query.filters)
               end
               def test_index_with_short_filters
                 to_test = {
                   'status_id' => {
                     'o' => { :op => 'o', :values => [''] },
                     'c' => { :op => 'c', :values => [''] },
                     '7' => { :op => '=', :values => ['7'] },
                     '7|3|4' => { :op => '=', :values => ['7', '3', '4'] },
                     '=7' => { :op => '=', :values => ['7'] },
                     '!3' => { :op => '!', :values => ['3'] },
                     '!7|3|4' => { :op => '!', :values => ['7', '3', '4'] }},
                   'subject' => {
                     'This is a subject' => { :op => '=', :values => ['This is a subject'] },
                     'o' => { :op => '=', :values => ['o'] },
                     '~This is part of a subject' => { :op => '~', :values => ['This is part of a subject'] },
                     '!~This is part of a subject' => { :op => '!~', :values => ['This is part of a subject'] }},
                   'tracker_id' => {
                     '3' => { :op => '=', :values => ['3'] },
                     '=3' => { :op => '=', :values => ['3'] }},
                   'start_date' => {
                     '2011-10-12' => { :op => '=', :values => ['2011-10-12'] },
                     '=2011-10-12' => { :op => '=', :values => ['2011-10-12'] },
                     '>=2011-10-12' => { :op => '>=', :values => ['2011-10-12'] },
                     '<=2011-10-12' => { :op => '<=', :values => ['2011-10-12'] },
                     '><2011-10-01|2011-10-30' => { :op => '><', :values => ['2011-10-01', '2011-10-30'] },
                     '<t+2' => { :op => '<t+', :values => ['2'] },
                     '>t+2' => { :op => '>t+', :values => ['2'] },
                     't+2' => { :op => 't+', :values => ['2'] },
                     't' => { :op => 't', :values => [''] },
                     'w' => { :op => 'w', :values => [''] },
                     '>t-2' => { :op => '>t-', :values => ['2'] },
                     '<t-2' => { :op => '<t-', :values => ['2'] },
                     't-2' => { :op => 't-', :values => ['2'] }},
                   'created_on' => {
                     '>=2011-10-12' => { :op => '>=', :values => ['2011-10-12'] },
                     '<t+2' => { :op => '=', :values => ['<t+2'] },
                     '>t+2' => { :op => '=', :values => ['>t+2'] },
                     't+2' => { :op => 't', :values => ['+2'] }},
                   'cf_1' => {
                     'c' => { :op => '=', :values => ['c'] },
                     '!c' => { :op => '!', :values => ['c'] },
                     '!*' => { :op => '!*', :values => [''] },
                     '*' => { :op => '*', :values => [''] }},
                   'estimated_hours' => {
                     '=13.4' => { :op => '=', :values => ['13.4'] },
                     '>=45' => { :op => '>=', :values => ['45'] },
                     '<=125' => { :op => '<=', :values => ['125'] },
                     '><10.5|20.5' => { :op => '><', :values => ['10.5', '20.5'] },
                     '!*' => { :op => '!*', :values => [''] },
                     '*' => { :op => '*', :values => [''] }}
                 }
                 default_filter = { 'status_id' => {:operator => 'o', :values => [''] }}
                 to_test.each do |field, expression_and_expected|
                   expression_and_expected.each do |filter_expression, expected|
                     get :index, :set_filter => 1, field => filter_expression
                     assert_response :success
                     assert_template 'index'
                     assert_not_nil assigns(:issues)
                     query = assigns(:query)
                     assert_not_nil query
                     assert query.has_filter?(field)
                     assert_equal(default_filter.merge({field => {:operator => expected[:op], :values => expected[:values]}}), query.filters)
                   end
                 end
               end
               def test_index_with_project_and_empty_filters
                 get :index, :project_id => 1, :set_filter => 1, :fields => ['']
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 query = assigns(:query)
                 assert_not_nil query
                 # no filter
                 assert_equal({}, query.filters)
               end
               def test_index_with_query
                 get :index, :project_id => 1, :query_id => 5
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_nil assigns(:issue_count_by_group)
               end
               def test_index_with_query_grouped_by_tracker
                 get :index, :project_id => 1, :query_id => 6
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_not_nil assigns(:issue_count_by_group)
               end
               def test_index_with_query_grouped_by_list_custom_field
                 get :index, :project_id => 1, :query_id => 9
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_not_nil assigns(:issue_count_by_group)
               end
               def test_index_with_query_id_and_project_id_should_set_session_query
                 get :index, :project_id => 1, :query_id => 4
                 assert_response :success
                 assert_kind_of Hash, session[:query]
                 assert_equal 4, session[:query][:id]
                 assert_equal 1, session[:query][:project_id]
               end
               def test_index_with_cross_project_query_in_session_should_show_project_issues
                 q = Query.create!(:name => "test", :user_id => 2, :is_public => false, :project => nil)
                 @request.session[:query] = {:id => q.id, :project_id => 1}
                 with_settings :display_subprojects_issues => '0' do
                   get :index, :project_id => 1
                 end
                 assert_response :success
                 assert_not_nil assigns(:query)
                 assert_equal q.id, assigns(:query).id
                 assert_equal 1, assigns(:query).project_id
                 assert_equal [1], assigns(:issues).map(&:project_id).uniq
               end
               def test_private_query_should_not_be_available_to_other_users
                 q = Query.create!(:name => "private", :user => User.find(2), :is_public => false, :project => nil)
                 @request.session[:user_id] = 3
                 get :index, :query_id => q.id
                 assert_response 403
               end
               def test_private_query_should_be_available_to_its_user
                 q = Query.create!(:name => "private", :user => User.find(2), :is_public => false, :project => nil)
                 @request.session[:user_id] = 2
                 get :index, :query_id => q.id
                 assert_response :success
               end
               def test_public_query_should_be_available_to_other_users
                 q = Query.create!(:name => "private", :user => User.find(2), :is_public => true, :project => nil)
                 @request.session[:user_id] = 3
                 get :index, :query_id => q.id
                 assert_response :success
               end
               def test_index_csv
                 get :index, :format => 'csv'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'text/csv', @response.content_type
                 assert @response.body.starts_with?("#,")
                 lines = @response.body.chomp.split("\n")
                 assert_equal assigns(:query).columns.size + 1, lines[0].split(',').size
               end
               def test_index_csv_with_project
                 get :index, :project_id => 1, :format => 'csv'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'text/csv', @response.content_type
               end
               def test_index_csv_with_description
                 get :index, :format => 'csv', :description => '1'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'text/csv', @response.content_type
                 assert @response.body.starts_with?("#,")
                 lines = @response.body.chomp.split("\n")
                 assert_equal assigns(:query).columns.size + 2, lines[0].split(',').size
               end
               def test_index_csv_with_all_columns
                 get :index, :format => 'csv', :columns => 'all'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'text/csv', @response.content_type
                 assert @response.body.starts_with?("#,")
                 lines = @response.body.chomp.split("\n")
                 assert_equal assigns(:query).available_columns.size + 1, lines[0].split(',').size
               end
               def test_index_csv_big_5
                 with_settings :default_language => "zh-TW" do
                   str_utf8  = "\xe4\xb8\x80\xe6\x9c\x88"
                   str_big5  = "\xa4@\xa4\xeb"
                   if str_utf8.respond_to?(:force_encoding)
                     str_utf8.force_encoding('UTF-8')
                     str_big5.force_encoding('Big5')
                   end
                   issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                     :status_id => 1, :priority => IssuePriority.all.first,
                                     :subject => str_utf8)
                   assert issue.save
                   get :index, :project_id => 1,
                               :f => ['subject'],
                               :op => '=', :values => [str_utf8],
                               :format => 'csv'
                   assert_equal 'text/csv', @response.content_type
                   lines = @response.body.chomp.split("\n")
                   s1 = "\xaa\xac\xbaA"
                   if str_utf8.respond_to?(:force_encoding)
                     s1.force_encoding('Big5')
                   end
                   assert lines[0].include?(s1)
                   assert lines[1].include?(str_big5)
                 end
               end
               def test_index_csv_cannot_convert_should_be_replaced_big_5
                 with_settings :default_language => "zh-TW" do
                   str_utf8  = "\xe4\xbb\xa5\xe5\x86\x85"
                   if str_utf8.respond_to?(:force_encoding)
                     str_utf8.force_encoding('UTF-8')
                   end
                   issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                     :status_id => 1, :priority => IssuePriority.all.first,
                                     :subject => str_utf8)
                   assert issue.save
                   get :index, :project_id => 1,
                               :f => ['subject'],
                               :op => '=', :values => [str_utf8],
                               :c => ['status', 'subject'],
                               :format => 'csv',
                               :set_filter => 1
                   assert_equal 'text/csv', @response.content_type
                   lines = @response.body.chomp.split("\n")
                   s1 = "\xaa\xac\xbaA" # status
                   if str_utf8.respond_to?(:force_encoding)
                     s1.force_encoding('Big5')
                   end
                   assert lines[0].include?(s1)
                   s2 = lines[1].split(",")[2]
                   if s1.respond_to?(:force_encoding)
                     s3 = "\xa5H?" # subject
                     s3.force_encoding('Big5')
                     assert_equal s3, s2
                   elsif RUBY_PLATFORM == 'java'
                     assert_equal "??", s2
                   else
                     assert_equal "\xa5H???", s2
                   end
                 end
               end
               def test_index_csv_tw
                 with_settings :default_language => "zh-TW" do
                   str1  = "test_index_csv_tw"
                   issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                     :status_id => 1, :priority => IssuePriority.all.first,
                                     :subject => str1, :estimated_hours => '1234.5')
                   assert issue.save
                   assert_equal 1234.5, issue.estimated_hours
                   get :index, :project_id => 1,
                               :f => ['subject'],
                               :op => '=', :values => [str1],
                               :c => ['estimated_hours', 'subject'],
                               :format => 'csv',
                               :set_filter => 1
                   assert_equal 'text/csv', @response.content_type
                   lines = @response.body.chomp.split("\n")
                   assert_equal "#{issue.id},1234.5,#{str1}", lines[1]
                   str_tw = "Traditional Chinese (\xe7\xb9\x81\xe9\xab\x94\xe4\xb8\xad\xe6\x96\x87)"
                   if str_tw.respond_to?(:force_encoding)
                     str_tw.force_encoding('UTF-8')
                   end
                   assert_equal str_tw, l(:general_lang_name)
                   assert_equal ',', l(:general_csv_separator)
                   assert_equal '.', l(:general_csv_decimal_separator)
                 end
               end
               def test_index_csv_fr
                 with_settings :default_language => "fr" do
                   str1  = "test_index_csv_fr"
                   issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                     :status_id => 1, :priority => IssuePriority.all.first,
                                     :subject => str1, :estimated_hours => '1234.5')
                   assert issue.save
                   assert_equal 1234.5, issue.estimated_hours
                   get :index, :project_id => 1,
                               :f => ['subject'],
                               :op => '=', :values => [str1],
                               :c => ['estimated_hours', 'subject'],
                               :format => 'csv',
                               :set_filter => 1
                   assert_equal 'text/csv', @response.content_type
                   lines = @response.body.chomp.split("\n")
                   assert_equal "#{issue.id};1234,5;#{str1}", lines[1]
                   str_fr = "Fran\xc3\xa7ais"
                   if str_fr.respond_to?(:force_encoding)
                     str_fr.force_encoding('UTF-8')
                   end
                   assert_equal str_fr, l(:general_lang_name)
                   assert_equal ';', l(:general_csv_separator)
                   assert_equal ',', l(:general_csv_decimal_separator)
                 end
               end
               def test_index_pdf
                 ["en", "zh", "zh-TW", "ja", "ko"].each do |lang|
                   with_settings :default_language => lang do
                     get :index
                     assert_response :success
                     assert_template 'index'
                     if lang == "ja"
                       if RUBY_PLATFORM != 'java'
                         assert_equal "CP932", l(:general_pdf_encoding)
                       end
                       if RUBY_PLATFORM == 'java' && l(:general_pdf_encoding) == "CP932"
                         next
                       end
                     end
                     get :index, :format => 'pdf'
                     assert_response :success
                     assert_not_nil assigns(:issues)
                     assert_equal 'application/pdf', @response.content_type
                     get :index, :project_id => 1, :format => 'pdf'
                     assert_response :success
                     assert_not_nil assigns(:issues)
                     assert_equal 'application/pdf', @response.content_type
                     get :index, :project_id => 1, :query_id => 6, :format => 'pdf'
                     assert_response :success
                     assert_not_nil assigns(:issues)
                     assert_equal 'application/pdf', @response.content_type
                   end
                 end
               end
               def test_index_pdf_with_query_grouped_by_list_custom_field
                 get :index, :project_id => 1, :query_id => 9, :format => 'pdf'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_not_nil assigns(:issue_count_by_group)
                 assert_equal 'application/pdf', @response.content_type
               end
               def test_index_sort
                 get :index, :sort => 'tracker,id:desc'
                 assert_response :success
                 sort_params = @request.session['issues_index_sort']
                 assert sort_params.is_a?(String)
                 assert_equal 'tracker,id:desc', sort_params
                 issues = assigns(:issues)
                 assert_not_nil issues
                 assert !issues.empty?
                 assert_equal issues.sort {|a,b| a.tracker == b.tracker ? b.id <=> a.id : a.tracker <=> b.tracker }.collect(&:id), issues.collect(&:id)
               end
               def test_index_sort_by_field_not_included_in_columns
                 Setting.issue_list_default_columns = %w(subject author)
                 get :index, :sort => 'tracker'
               end
               def test_index_sort_by_assigned_to
                 get :index, :sort => 'assigned_to'
                 assert_response :success
                 assignees = assigns(:issues).collect(&:assigned_to).compact
                 assert_equal assignees.sort, assignees
               end
               def test_index_sort_by_assigned_to_desc
                 get :index, :sort => 'assigned_to:desc'
                 assert_response :success
                 assignees = assigns(:issues).collect(&:assigned_to).compact
                 assert_equal assignees.sort.reverse, assignees
               end
               def test_index_group_by_assigned_to
                 get :index, :group_by => 'assigned_to', :sort => 'priority'
                 assert_response :success
               end
               def test_index_sort_by_author
                 get :index, :sort => 'author'
                 assert_response :success
                 authors = assigns(:issues).collect(&:author)
                 assert_equal authors.sort, authors
               end
               def test_index_sort_by_author_desc
                 get :index, :sort => 'author:desc'
                 assert_response :success
                 authors = assigns(:issues).collect(&:author)
                 assert_equal authors.sort.reverse, authors
               end
               def test_index_group_by_author
                 get :index, :group_by => 'author', :sort => 'priority'
                 assert_response :success
               end
               def test_index_sort_by_spent_hours
                 get :index, :sort => 'spent_hours:desc'
                 assert_response :success
                 hours = assigns(:issues).collect(&:spent_hours)
                 assert_equal hours.sort.reverse, hours
               end
               def test_index_with_columns
                 columns = ['tracker', 'subject', 'assigned_to']
                 get :index, :set_filter => 1, :c => columns
                 assert_response :success
                 # query should use specified columns
                 query = assigns(:query)
                 assert_kind_of Query, query
                 assert_equal columns, query.column_names.map(&:to_s)
                 # columns should be stored in session
                 assert_kind_of Hash, session[:query]
                 assert_kind_of Array, session[:query][:column_names]
                 assert_equal columns, session[:query][:column_names].map(&:to_s)
                 # ensure only these columns are kept in the selected columns list
                 assert_tag :tag => 'select', :attributes => { :id => 'selected_columns' },
                                              :children => { :count => 3 }
                 assert_no_tag :tag => 'option', :attributes => { :value => 'project' },
                                                 :parent => { :tag => 'select', :attributes => { :id => "selected_columns" } }
               end
               def test_index_without_project_should_implicitly_add_project_column_to_default_columns
                 Setting.issue_list_default_columns = ['tracker', 'subject', 'assigned_to']
                 get :index, :set_filter => 1
                 # query should use specified columns
                 query = assigns(:query)
                 assert_kind_of Query, query
                 assert_equal [:project, :tracker, :subject, :assigned_to], query.columns.map(&:name)
               end
               def test_index_without_project_and_explicit_default_columns_should_not_add_project_column
                 Setting.issue_list_default_columns = ['tracker', 'subject', 'assigned_to']
                 columns = ['tracker', 'subject', 'assigned_to']
                 get :index, :set_filter => 1, :c => columns
                 # query should use specified columns
                 query = assigns(:query)
                 assert_kind_of Query, query
                 assert_equal columns.map(&:to_sym), query.columns.map(&:name)
               end
               def test_index_with_custom_field_column
                 columns = %w(tracker subject cf_2)
                 get :index, :set_filter => 1, :c => columns
                 assert_response :success
                 # query should use specified columns
                 query = assigns(:query)
                 assert_kind_of Query, query
                 assert_equal columns, query.column_names.map(&:to_s)
                 assert_tag :td,
                   :attributes => {:class => 'cf_2 string'},
                   :ancestor => {:tag => 'table', :attributes => {:class => /issues/}}
               end
               def test_index_with_date_column
                 Issue.find(1).update_attribute :start_date, '1987-08-24'
                 with_settings :date_format => '%d/%m/%Y' do
                   get :index, :set_filter => 1, :c => %w(start_date)
                   assert_tag 'td', :attributes => {:class => /start_date/}, :content => '24/08/1987'
                 end
               end
               def test_index_with_done_ratio
                 Issue.find(1).update_attribute :done_ratio, 40
                 get :index, :set_filter => 1, :c => %w(done_ratio)
                 assert_tag 'td', :attributes => {:class => /done_ratio/},
                   :child => {:tag => 'table', :attributes => {:class => 'progress'},
                     :descendant => {:tag => 'td', :attributes => {:class => 'closed', :style => 'width: 40%;'}}
                   }
               end
               def test_index_with_spent_hours_column
                 get :index, :set_filter => 1, :c => %w(subject spent_hours)
                 assert_tag 'tr', :attributes => {:id => 'issue-3'},
                   :child => {
                     :tag => 'td', :attributes => {:class => /spent_hours/}, :content => '1.00'
                   }
               end
               def test_index_should_not_show_spent_hours_column_without_permission
                 Role.anonymous.remove_permission! :view_time_entries
                 get :index, :set_filter => 1, :c => %w(subject spent_hours)
                 assert_no_tag 'td', :attributes => {:class => /spent_hours/}
               end
               def test_index_with_fixed_version
                 get :index, :set_filter => 1, :c => %w(fixed_version)
                 assert_tag 'td', :attributes => {:class => /fixed_version/},
                   :child => {:tag => 'a', :content => '1.0', :attributes => {:href => '/versions/2'}}
               end
               def test_index_send_html_if_query_is_invalid
                 get :index, :f => ['start_date'], :op => {:start_date => '='}
                 assert_equal 'text/html', @response.content_type
                 assert_template 'index'
               end
               def test_index_send_nothing_if_query_is_invalid
                 get :index, :f => ['start_date'], :op => {:start_date => '='}, :format => 'csv'
                 assert_equal 'text/csv', @response.content_type
                 assert @response.body.blank?
               end
               def test_show_by_anonymous
                 get :show, :id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:issue)
                 assert_equal Issue.find(1), assigns(:issue)
                 # anonymous role is allowed to add a note
                 assert_tag :tag => 'form',
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Notes/ } }
                 assert_tag :tag => 'title',
                   :content => "Bug #1: Can't print recipes - eCookbook - Redmine"
               end
               def test_show_by_manager
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert_tag :tag => 'a',
                   :content => /Quote/
                 assert_tag :tag => 'form',
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Change properties/ } },
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Log time/ } },
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Notes/ } }
               end
               def test_show_should_display_update_form
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert_tag 'form', :attributes => {:id => 'issue-form'}
                 assert_tag 'input', :attributes => {:name => 'issue[is_private]'}
                 assert_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[tracker_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[subject]'}
                 assert_tag 'textarea', :attributes => {:name => 'issue[description]'}
                 assert_tag 'select', :attributes => {:name => 'issue[status_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[priority_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[assigned_to_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[category_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[fixed_version_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[parent_issue_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[start_date]'}
                 assert_tag 'input', :attributes => {:name => 'issue[due_date]'}
                 assert_tag 'select', :attributes => {:name => 'issue[done_ratio]'}
                 assert_tag 'input', :attributes => { :name => 'issue[custom_field_values][2]' }
                 assert_no_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]'}
                 assert_tag 'textarea', :attributes => {:name => 'notes'}
               end
               def test_show_should_display_update_form_with_minimal_permissions
                 Role.find(1).update_attribute :permissions, [:view_issues, :add_issue_notes]
                 Workflow.delete_all :role_id => 1
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert_tag 'form', :attributes => {:id => 'issue-form'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[is_private]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[tracker_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[subject]'}
                 assert_no_tag 'textarea', :attributes => {:name => 'issue[description]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[status_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[priority_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[assigned_to_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[category_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[fixed_version_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[parent_issue_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[start_date]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[due_date]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[done_ratio]'}
                 assert_no_tag 'input', :attributes => { :name => 'issue[custom_field_values][2]' }
                 assert_no_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]'}
                 assert_tag 'textarea', :attributes => {:name => 'notes'}
               end
               def test_show_should_display_update_form_with_workflow_permissions
                 Role.find(1).update_attribute :permissions, [:view_issues, :add_issue_notes]
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert_tag 'form', :attributes => {:id => 'issue-form'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[is_private]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[tracker_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[subject]'}
                 assert_no_tag 'textarea', :attributes => {:name => 'issue[description]'}
                 assert_tag 'select', :attributes => {:name => 'issue[status_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[priority_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[assigned_to_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[category_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[fixed_version_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[parent_issue_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[start_date]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[due_date]'}
                 assert_tag 'select', :attributes => {:name => 'issue[done_ratio]'}
                 assert_no_tag 'input', :attributes => { :name => 'issue[custom_field_values][2]' }
                 assert_no_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]'}
                 assert_tag 'textarea', :attributes => {:name => 'notes'}
               end
               def test_show_should_not_display_update_form_without_permissions
                 Role.find(1).update_attribute :permissions, [:view_issues]
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert_no_tag 'form', :attributes => {:id => 'issue-form'}
               end
               def test_update_form_should_not_display_inactive_enumerations
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert ! IssuePriority.find(15).active?
                 assert_no_tag :option, :attributes => {:value => '15'},
                                        :parent => {:tag => 'select', :attributes => {:id => 'issue_priority_id'} }
               end
               def test_update_form_should_allow_attachment_upload
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_tag :tag => 'form',
                   :attributes => {:id => 'issue-form', :method => 'post', :enctype => 'multipart/form-data'},
                   :descendant => {
                     :tag => 'input',
                     :attributes => {:type => 'file', :name => 'attachments[1][file]'}
                   }
               end
               def test_show_should_deny_anonymous_access_without_permission
                 Role.anonymous.remove_permission!(:view_issues)
                 get :show, :id => 1
                 assert_response :redirect
               end
               def test_show_should_deny_anonymous_access_to_private_issue
                 Issue.update_all(["is_private = ?", true], "id = 1")
                 get :show, :id => 1
                 assert_response :redirect
               end
               def test_show_should_deny_non_member_access_without_permission
                 Role.non_member.remove_permission!(:view_issues)
                 @request.session[:user_id] = 9
                 get :show, :id => 1
                 assert_response 403
               end
               def test_show_should_deny_non_member_access_to_private_issue
                 Issue.update_all(["is_private = ?", true], "id = 1")
                 @request.session[:user_id] = 9
                 get :show, :id => 1
                 assert_response 403
               end
               def test_show_should_deny_member_access_without_permission
                 Role.find(1).remove_permission!(:view_issues)
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response 403
               end
               def test_show_should_deny_member_access_to_private_issue_without_permission
                 Issue.update_all(["is_private = ?", true], "id = 1")
                 @request.session[:user_id] = 3
                 get :show, :id => 1
                 assert_response 403
               end
               def test_show_should_allow_author_access_to_private_issue
                 Issue.update_all(["is_private = ?, author_id = 3", true], "id = 1")
                 @request.session[:user_id] = 3
                 get :show, :id => 1
                 assert_response :success
               end
               def test_show_should_allow_assignee_access_to_private_issue
                 Issue.update_all(["is_private = ?, assigned_to_id = 3", true], "id = 1")
                 @request.session[:user_id] = 3
                 get :show, :id => 1
                 assert_response :success
               end
               def test_show_should_allow_member_access_to_private_issue_with_permission
                 Issue.update_all(["is_private = ?", true], "id = 1")
                 User.find(3).roles_for_project(Project.find(1)).first.update_attribute :issues_visibility, 'all'
                 @request.session[:user_id] = 3
                 get :show, :id => 1
                 assert_response :success
               end
               def test_show_should_not_disclose_relations_to_invisible_issues
                 Setting.cross_project_issue_relations = '1'
                 IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(2), :relation_type => 'relates')
                 # Relation to a private project issue
                 IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(4), :relation_type => 'relates')
                 get :show, :id => 1
                 assert_response :success
                 assert_tag :div, :attributes => { :id => 'relations' },
                                  :descendant => { :tag => 'a', :content => /#2$/ }
                 assert_no_tag :div, :attributes => { :id => 'relations' },
                                     :descendant => { :tag => 'a', :content => /#4$/ }
               end
               def test_show_should_list_subtasks
                 Issue.generate!(:project_id => 1, :author_id => 1, :tracker_id => 1, :parent_issue_id => 1, :subject => 'Child Issue')
                 get :show, :id => 1
                 assert_response :success
                 assert_tag 'div', :attributes => {:id => 'issue_tree'},
                   :descendant => {:tag => 'td', :content => /Child Issue/, :attributes => {:class => /subject/}}
               end
               def test_show_should_list_parents
                 issue = Issue.generate!(:project_id => 1, :author_id => 1, :tracker_id => 1, :parent_issue_id => 1, :subject => 'Child Issue')
                 get :show, :id => issue.id
                 assert_response :success
                 assert_tag 'div', :attributes => {:class => 'subject'},
                   :descendant => {:tag => 'h3', :content => 'Child Issue'}
                 assert_tag 'div', :attributes => {:class => 'subject'},
                   :descendant => {:tag => 'a', :attributes => {:href => '/issues/1'}}
               end
               def test_show_should_not_display_prev_next_links_without_query_in_session
                 get :show, :id => 1
                 assert_response :success
                 assert_nil assigns(:prev_issue_id)
                 assert_nil assigns(:next_issue_id)
               end
               def test_show_should_display_prev_next_links_with_query_in_session
                 @request.session[:query] = {:filters => {'status_id' => {:values => [''], :operator => 'o'}}, :project_id => nil}
                 @request.session['issues_index_sort'] = 'id'
                 with_settings :display_subprojects_issues => '0' do
                   get :show, :id => 3
                 end
                 assert_response :success
                 # Previous and next issues for all projects
                 assert_equal 2, assigns(:prev_issue_id)
                 assert_equal 5, assigns(:next_issue_id)
                 assert_tag 'a', :attributes => {:href => '/issues/2'}, :content => /Previous/
                 assert_tag 'a', :attributes => {:href => '/issues/5'}, :content => /Next/
               end
               def test_show_should_display_prev_next_links_with_project_query_in_session
                 @request.session[:query] = {:filters => {'status_id' => {:values => [''], :operator => 'o'}}, :project_id => 1}
                 @request.session['issues_index_sort'] = 'id'
                 with_settings :display_subprojects_issues => '0' do
                   get :show, :id => 3
                 end
                 assert_response :success
                 # Previous and next issues inside project
                 assert_equal 2, assigns(:prev_issue_id)
                 assert_equal 7, assigns(:next_issue_id)
                 assert_tag 'a', :attributes => {:href => '/issues/2'}, :content => /Previous/
                 assert_tag 'a', :attributes => {:href => '/issues/7'}, :content => /Next/
               end
               def test_show_should_not_display_prev_link_for_first_issue
                 @request.session[:query] = {:filters => {'status_id' => {:values => [''], :operator => 'o'}}, :project_id => 1}
                 @request.session['issues_index_sort'] = 'id'
                 with_settings :display_subprojects_issues => '0' do
                   get :show, :id => 1
                 end
                 assert_response :success
                 assert_nil assigns(:prev_issue_id)
                 assert_equal 2, assigns(:next_issue_id)
                 assert_no_tag 'a', :content => /Previous/
                 assert_tag 'a', :attributes => {:href => '/issues/2'}, :content => /Next/
               end
               def test_show_should_not_display_prev_next_links_for_issue_not_in_query_results
                 @request.session[:query] = {:filters => {'status_id' => {:values => [''], :operator => 'c'}}, :project_id => 1}
                 @request.session['issues_index_sort'] = 'id'
                 get :show, :id => 1
                 assert_response :success
                 assert_nil assigns(:prev_issue_id)
                 assert_nil assigns(:next_issue_id)
                 assert_no_tag 'a', :content => /Previous/
                 assert_no_tag 'a', :content => /Next/
               end
               def test_show_atom
                 get :show, :id => 2, :format => 'atom'
                 assert_response :success
                 assert_template 'journals/index'
                 # Inline image
                 assert_select 'content', :text => Regexp.new(Regexp.quote('http://test.host/attachments/download/10'))
               end
               def test_show_export_to_pdf
                 get :show, :id => 3, :format => 'pdf'
                 assert_response :success
                 assert_equal 'application/pdf', @response.content_type
                 assert @response.body.starts_with?('%PDF')
                 assert_not_nil assigns(:issue)
               end
               def test_get_new
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_tag 'input', :attributes => {:name => 'issue[is_private]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[tracker_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[subject]'}
                 assert_tag 'textarea', :attributes => {:name => 'issue[description]'}
                 assert_tag 'select', :attributes => {:name => 'issue[status_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[priority_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[assigned_to_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[category_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[fixed_version_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[parent_issue_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[start_date]'}
                 assert_tag 'input', :attributes => {:name => 'issue[due_date]'}
                 assert_tag 'select', :attributes => {:name => 'issue[done_ratio]'}
                 assert_tag 'input', :attributes => { :name => 'issue[custom_field_values][2]', :value => 'Default string' }
                 assert_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]'}
                 # Be sure we don't display inactive IssuePriorities
                 assert ! IssuePriority.find(15).active?
                 assert_no_tag :option, :attributes => {:value => '15'},
                                        :parent => {:tag => 'select', :attributes => {:id => 'issue_priority_id'} }
               end
               def test_get_new_with_minimal_permissions
                 Role.find(1).update_attribute :permissions, [:add_issues]
                 Workflow.delete_all :role_id => 1
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_no_tag 'input', :attributes => {:name => 'issue[is_private]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[tracker_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[subject]'}
                 assert_tag 'textarea', :attributes => {:name => 'issue[description]'}
                 assert_tag 'select', :attributes => {:name => 'issue[status_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[priority_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[assigned_to_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[category_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[fixed_version_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[parent_issue_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[start_date]'}
                 assert_tag 'input', :attributes => {:name => 'issue[due_date]'}
                 assert_tag 'select', :attributes => {:name => 'issue[done_ratio]'}
                 assert_tag 'input', :attributes => { :name => 'issue[custom_field_values][2]', :value => 'Default string' }
                 assert_no_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]'}
               end
               def test_get_new_without_default_start_date_is_creation_date
                 Setting.default_issue_start_date_to_creation_date = 0
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_tag :tag => 'input', :attributes => { :name => 'issue[start_date]',
                                                              :value => nil }
               end
               def test_get_new_with_default_start_date_is_creation_date
                 Setting.default_issue_start_date_to_creation_date = 1
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_tag :tag => 'input', :attributes => { :name => 'issue[start_date]',
                                                              :value => Date.today.to_s }
               end
               def test_get_new_form_should_allow_attachment_upload
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_tag :tag => 'form',
                   :attributes => {:id => 'issue-form', :method => 'post', :enctype => 'multipart/form-data'},
                   :descendant => {
                     :tag => 'input',
                     :attributes => {:type => 'file', :name => 'attachments[1][file]'}
                   }
               end
               def test_get_new_without_tracker_id
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1
                 assert_response :success
                 assert_template 'new'
                 issue = assigns(:issue)
                 assert_not_nil issue
                 assert_equal Project.find(1).trackers.first, issue.tracker
               end
               def test_get_new_with_no_default_status_should_display_an_error
                 @request.session[:user_id] = 2
                 IssueStatus.delete_all
                 get :new, :project_id => 1
                 assert_response 500
                 assert_error_tag :content => /No default issue/
               end
               def test_get_new_with_no_tracker_should_display_an_error
                 @request.session[:user_id] = 2
                 Tracker.delete_all
                 get :new, :project_id => 1
                 assert_response 500
                 assert_error_tag :content => /No tracker/
               end
               def test_update_new_form
                 @request.session[:user_id] = 2
                 xhr :post, :new, :project_id => 1,
                                  :issue => {:tracker_id => 2,
                                             :subject => 'This is the test_new issue',
                                             :description => 'This is the description',
                                             :priority_id => 5}
                 assert_response :success
                 assert_template 'attributes'
                 issue = assigns(:issue)
                 assert_kind_of Issue, issue
                 assert_equal 1, issue.project_id
                 assert_equal 2, issue.tracker_id
                 assert_equal 'This is the test_new issue', issue.subject
               end
               def test_post_create
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 3,
                                         :status_id => 2,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :start_date => '2010-11-07',
                                         :estimated_hours => '',
                                         :custom_field_values => {'2' => 'Value for field 2'}}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 issue = Issue.find_by_subject('This is the test_new issue')
                 assert_not_nil issue
                 assert_equal 2, issue.author_id
                 assert_equal 3, issue.tracker_id
                 assert_equal 2, issue.status_id
                 assert_equal Date.parse('2010-11-07'), issue.start_date
                 assert_nil issue.estimated_hours
                 v = issue.custom_values.find(:first, :conditions => {:custom_field_id => 2})
                 assert_not_nil v
                 assert_equal 'Value for field 2', v.value
               end
               def test_post_new_with_group_assignment
                 group = Group.find(11)
                 project = Project.find(1)
                 project.members << Member.new(:principal => group, :roles => [Role.first])
                 with_settings :issue_group_assignment => '1' do
                   @request.session[:user_id] = 2
                   assert_difference 'Issue.count' do
                     post :create, :project_id => project.id,
                                   :issue => {:tracker_id => 3,
                                              :status_id => 1,
                                              :subject => 'This is the test_new_with_group_assignment issue',
                                              :assigned_to_id => group.id}
                   end
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 issue = Issue.find_by_subject('This is the test_new_with_group_assignment issue')
                 assert_not_nil issue
                 assert_equal group, issue.assigned_to
               end
               def test_post_create_without_start_date_and_default_start_date_is_not_creation_date
                 Setting.default_issue_start_date_to_creation_date = 0
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 3,
                                         :status_id => 2,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :estimated_hours => '',
                                         :custom_field_values => {'2' => 'Value for field 2'}}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 issue = Issue.find_by_subject('This is the test_new issue')
                 assert_not_nil issue
                 assert_nil issue.start_date
               end
               def test_post_create_without_start_date_and_default_start_date_is_creation_date
                 Setting.default_issue_start_date_to_creation_date = 1
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 3,
                                         :status_id => 2,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :estimated_hours => '',
                                         :custom_field_values => {'2' => 'Value for field 2'}}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 issue = Issue.find_by_subject('This is the test_new issue')
                 assert_not_nil issue
                 assert_equal Date.today, issue.start_date
               end
               def test_post_create_and_continue
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                     :issue => {:tracker_id => 3, :subject => 'This is first issue', :priority_id => 5},
                     :continue => ''
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert_redirected_to :controller => 'issues', :action => 'new', :project_id => 'ecookbook', :issue => {:tracker_id => 3}
                 assert_not_nil flash[:notice], "flash was not set"
                 assert flash[:notice].include?("<a href='/issues/#{issue.id}'>##{issue.id}</a>"), "issue link not found in flash: #{flash[:notice]}"
               end
               def test_post_create_without_custom_fields_param
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
               end
               def test_post_create_with_required_custom_field_and_without_custom_fields_param
                 field = IssueCustomField.find_by_name('Database')
                 field.update_attribute(:is_required, true)
                 @request.session[:user_id] = 2
                 post :create, :project_id => 1,
                            :issue => {:tracker_id => 1,
                                       :subject => 'This is the test_new issue',
                                       :description => 'This is the description',
                                       :priority_id => 5}
                 assert_response :success
                 assert_template 'new'
                 issue = assigns(:issue)
                 assert_not_nil issue
                 assert_equal I18n.translate('activerecord.errors.messages.invalid'),
                              issue.errors[:custom_values].to_s
               end
               def test_post_create_with_watchers
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 assert_difference 'Watcher.count', 2 do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is a new issue with watchers',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :watcher_user_ids => ['2', '3']}
                 end
                 issue = Issue.find_by_subject('This is a new issue with watchers')
                 assert_not_nil issue
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => issue
                 # Watchers added
                 assert_equal [2, 3], issue.watcher_user_ids.sort
                 assert issue.watched_by?(User.find(3))
                 # Watchers notified
                 mail = ActionMailer::Base.deliveries.last
                 assert_kind_of TMail::Mail, mail
                 assert [mail.bcc, mail.cc].flatten.include?(User.find(3).mail)
               end
               def test_post_create_subissue
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is a child issue',
                                         :parent_issue_id => 2}
                 end
                 issue = Issue.find_by_subject('This is a child issue')
                 assert_not_nil issue
                 assert_equal Issue.find(2), issue.parent
               end
               def test_post_create_subissue_with_non_numeric_parent_id
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is a child issue',
                                         :parent_issue_id => 'ABC'}
                 end
                 issue = Issue.find_by_subject('This is a child issue')
                 assert_not_nil issue
                 assert_nil issue.parent
               end
               def test_post_create_private
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is a private issue',
                                         :is_private => '1'}
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert issue.is_private?
               end
               def test_post_create_private_with_set_own_issues_private_permission
                 role = Role.find(1)
                 role.remove_permission! :set_issues_private
                 role.add_permission! :set_own_issues_private
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is a private issue',
                                         :is_private => '1'}
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert issue.is_private?
               end
               def test_post_create_should_send_a_notification
                 ActionMailer::Base.deliveries.clear
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 3,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :estimated_hours => '',
                                         :custom_field_values => {'2' => 'Value for field 2'}}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_post_create_should_preserve_fields_values_on_validation_failure
                 @request.session[:user_id] = 2
                 post :create, :project_id => 1,
                            :issue => {:tracker_id => 1,
                                       # empty subject
                                       :subject => '',
                                       :description => 'This is a description',
                                       :priority_id => 6,
                                       :custom_field_values => {'1' => 'Oracle', '2' => 'Value for field 2'}}
                 assert_response :success
                 assert_template 'new'
                 assert_tag :textarea, :attributes => { :name => 'issue[description]' },
                                       :content => 'This is a description'
                 assert_tag :select, :attributes => { :name => 'issue[priority_id]' },
                                     :child => { :tag => 'option', :attributes => { :selected => 'selected',
                                                                                    :value => '6' },
                                                                   :content => 'High' }
                 # Custom fields
                 assert_tag :select, :attributes => { :name => 'issue[custom_field_values][1]' },
                                     :child => { :tag => 'option', :attributes => { :selected => 'selected',
                                                                                    :value => 'Oracle' },
                                                                   :content => 'Oracle' }
                 assert_tag :input, :attributes => { :name => 'issue[custom_field_values][2]',
                                                     :value => 'Value for field 2'}
               end
               def test_post_create_should_ignore_non_safe_attributes
                 @request.session[:user_id] = 2
                 assert_nothing_raised do
                   post :create, :project_id => 1, :issue => { :tracker => "A param can not be a Tracker" }
                 end
               end
               def test_post_create_with_attachment
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   assert_difference 'Attachment.count' do
                     post :create, :project_id => 1,
                       :issue => { :tracker_id => '1', :subject => 'With attachment' },
                       :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                   end
                 end
                 issue = Issue.first(:order => 'id DESC')
                 attachment = Attachment.first(:order => 'id DESC')
                 assert_equal issue, attachment.container
                 assert_equal 2, attachment.author_id
                 assert_equal 'testfile.txt', attachment.filename
                 assert_equal 'text/plain', attachment.content_type
                 assert_equal 'test file', attachment.description
                 assert_equal 59, attachment.filesize
                 assert File.exists?(attachment.diskfile)
                 assert_equal 59, File.size(attachment.diskfile)
               end
               context "without workflow privilege" do
                 setup do
                   Workflow.delete_all(["role_id = ?", Role.anonymous.id])
                   Role.anonymous.add_permission! :add_issues, :add_issue_notes
                 end
                 context "#new" do
                   should "propose default status only" do
                     get :new, :project_id => 1
                     assert_response :success
                     assert_template 'new'
                     assert_tag :tag => 'select',
                       :attributes => {:name => 'issue[status_id]'},
                       :children => {:count => 1},
                       :child => {:tag => 'option', :attributes => {:value => IssueStatus.default.id.to_s}}
                   end
                   should "accept default status" do
                     assert_difference 'Issue.count' do
                       post :create, :project_id => 1,
                                  :issue => {:tracker_id => 1,
                                             :subject => 'This is an issue',
                                             :status_id => 1}
                     end
                     issue = Issue.last(:order => 'id')
                     assert_equal IssueStatus.default, issue.status
                   end
                   should "ignore unauthorized status" do
                     assert_difference 'Issue.count' do
                       post :create, :project_id => 1,
                                  :issue => {:tracker_id => 1,
                                             :subject => 'This is an issue',
                                             :status_id => 3}
                     end
                     issue = Issue.last(:order => 'id')
                     assert_equal IssueStatus.default, issue.status
                   end
                 end
                 context "#update" do
                   should "ignore status change" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:status_id => 3}
                     end
                     assert_equal 1, Issue.find(1).status_id
                   end
                   should "ignore attributes changes" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:subject => 'changed', :assigned_to_id => 2}
                     end
                     issue = Issue.find(1)
                     assert_equal "Can't print recipes", issue.subject
                     assert_nil issue.assigned_to
                   end
                 end
               end
               context "with workflow privilege" do
                 setup do
                   Workflow.delete_all(["role_id = ?", Role.anonymous.id])
                   Workflow.create!(:role => Role.anonymous, :tracker_id => 1, :old_status_id => 1, :new_status_id => 3)
                   Workflow.create!(:role => Role.anonymous, :tracker_id => 1, :old_status_id => 1, :new_status_id => 4)
                   Role.anonymous.add_permission! :add_issues, :add_issue_notes
                 end
                 context "#update" do
                   should "accept authorized status" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:status_id => 3}
                     end
                     assert_equal 3, Issue.find(1).status_id
                   end
                   should "ignore unauthorized status" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:status_id => 2}
                     end
                     assert_equal 1, Issue.find(1).status_id
                   end
                   should "accept authorized attributes changes" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:assigned_to_id => 2}
                     end
                     issue = Issue.find(1)
                     assert_equal 2, issue.assigned_to_id
                   end
                   should "ignore unauthorized attributes changes" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:subject => 'changed'}
                     end
                     issue = Issue.find(1)
                     assert_equal "Can't print recipes", issue.subject
                   end
                 end
                 context "and :edit_issues permission" do
                   setup do
                     Role.anonymous.add_permission! :add_issues, :edit_issues
                   end
                   should "accept authorized status" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:status_id => 3}
                     end
                     assert_equal 3, Issue.find(1).status_id
                   end
                   should "ignore unauthorized status" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:status_id => 2}
                     end
                     assert_equal 1, Issue.find(1).status_id
                   end
                   should "accept authorized attributes changes" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:subject => 'changed', :assigned_to_id => 2}
                     end
                     issue = Issue.find(1)
                     assert_equal "changed", issue.subject
                     assert_equal 2, issue.assigned_to_id
                   end
                 end
               end
               def test_copy_issue
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :copy_from => 1
                 assert_template 'new'
                 assert_not_nil assigns(:issue)
                 orig = Issue.find(1)
                 assert_equal orig.subject, assigns(:issue).subject
               end
               def test_get_edit
                 @request.session[:user_id] = 2
                 get :edit, :id => 1
                 assert_response :success
                 assert_template 'edit'
                 assert_not_nil assigns(:issue)
                 assert_equal Issue.find(1), assigns(:issue)
                 # Be sure we don't display inactive IssuePriorities
                 assert ! IssuePriority.find(15).active?
                 assert_no_tag :option, :attributes => {:value => '15'},
                                        :parent => {:tag => 'select', :attributes => {:id => 'issue_priority_id'} }
               end
               def test_get_edit_should_display_the_time_entry_form_with_log_time_permission
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').update_attribute :permissions, [:view_issues, :edit_issues, :log_time]
                 get :edit, :id => 1
                 assert_tag 'input', :attributes => {:name => 'time_entry[hours]'}
               end
               def test_get_edit_should_not_display_the_time_entry_form_without_log_time_permission
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :log_time
                 get :edit, :id => 1
                 assert_no_tag 'input', :attributes => {:name => 'time_entry[hours]'}
               end
               def test_get_edit_with_params
                 @request.session[:user_id] = 2
                 get :edit, :id => 1, :issue => { :status_id => 5, :priority_id => 7 },
                     :time_entry => { :hours => '2.5', :comments => 'test_get_edit_with_params', :activity_id => TimeEntryActivity.first.id }
                 assert_response :success
                 assert_template 'edit'
                 issue = assigns(:issue)
                 assert_not_nil issue
                 assert_equal 5, issue.status_id
                 assert_tag :select, :attributes => { :name => 'issue[status_id]' },
                                     :child => { :tag => 'option',
                                                 :content => 'Closed',
                                                 :attributes => { :selected => 'selected' } }
                 assert_equal 7, issue.priority_id
                 assert_tag :select, :attributes => { :name => 'issue[priority_id]' },
                                     :child => { :tag => 'option',
                                                 :content => 'Urgent',
                                                 :attributes => { :selected => 'selected' } }
                 assert_tag :input, :attributes => { :name => 'time_entry[hours]', :value => '2.5' }
                 assert_tag :select, :attributes => { :name => 'time_entry[activity_id]' },
                                     :child => { :tag => 'option',
                                                 :attributes => { :selected => 'selected', :value => TimeEntryActivity.first.id } }
                 assert_tag :input, :attributes => { :name => 'time_entry[comments]', :value => 'test_get_edit_with_params' }
               end
               def test_update_edit_form
                 @request.session[:user_id] = 2
                 xhr :put, :new, :project_id => 1,
                                          :id => 1,
                                          :issue => {:tracker_id => 2,
                                                     :subject => 'This is the test_new issue',
                                                     :description => 'This is the description',
                                                     :priority_id => 5}
                 assert_response :success
                 assert_template 'attributes'
                 issue = assigns(:issue)
                 assert_kind_of Issue, issue
                 assert_equal 1, issue.id
                 assert_equal 1, issue.project_id
                 assert_equal 2, issue.tracker_id
                 assert_equal 'This is the test_new issue', issue.subject
               end
               def test_update_edit_form_with_project_change
                 @request.session[:user_id] = 2
                 xhr :put, :new, :project_id => 1,
                                          :id => 1,
                                          :project_change => '1',
                                          :issue => {:project_id => 2,
                                                     :tracker_id => 2,
                                                     :subject => 'This is the test_new issue',
                                                     :description => 'This is the description',
                                                     :priority_id => 5}
                 assert_response :success
                 assert_template 'form'
                 issue = assigns(:issue)
                 assert_kind_of Issue, issue
                 assert_equal 1, issue.id
                 assert_equal 2, issue.project_id
                 assert_equal 2, issue.tracker_id
                 assert_equal 'This is the test_new issue', issue.subject
               end
               def test_update_using_invalid_http_verbs
                 @request.session[:user_id] = 2
                 subject = 'Updated by an invalid http verb'
                 get :update, :id => 1, :issue => {:subject => subject}
                 assert_not_equal subject, Issue.find(1).subject
                 post :update, :id => 1, :issue => {:subject => subject}
                 assert_not_equal subject, Issue.find(1).subject
                 delete :update, :id => 1, :issue => {:subject => subject}
                 assert_not_equal subject, Issue.find(1).subject
               end
               def test_put_update_without_custom_fields_param
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 issue = Issue.find(1)
                 assert_equal '125', issue.custom_value_for(2).value
                 old_subject = issue.subject
                 new_subject = 'Subject modified by IssuesControllerTest#test_post_edit'
                 assert_difference('Journal.count') do
                   assert_difference('JournalDetail.count', 2) do
                     put :update, :id => 1, :issue => {:subject => new_subject,
                                                      :priority_id => '6',
                                                      :category_id => '1' # no change
                                                     }
                   end
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert_equal new_subject, issue.subject
                 # Make sure custom fields were not cleared
                 assert_equal '125', issue.custom_value_for(2).value
                 mail = ActionMailer::Base.deliveries.last
                 assert_kind_of TMail::Mail, mail
                 assert mail.subject.starts_with?("[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}]")
                 assert mail.body.include?("Subject changed from #{old_subject} to #{new_subject}")
               end
               def test_put_update_with_project_change
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 assert_difference('Journal.count') do
                   assert_difference('JournalDetail.count', 3) do
                     put :update, :id => 1, :issue => {:project_id => '2',
                                                      :tracker_id => '1', # no change
                                                      :priority_id => '6',
                                                      :category_id => '3'
                                                     }
                   end
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue = Issue.find(1)
                 assert_equal 2, issue.project_id
                 assert_equal 1, issue.tracker_id
                 assert_equal 6, issue.priority_id
                 assert_equal 3, issue.category_id
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert mail.subject.starts_with?("[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}]")
                 assert mail.body.include?("Project changed from eCookbook to OnlineStore")
               end
               def test_put_update_with_tracker_change
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 assert_difference('Journal.count') do
                   assert_difference('JournalDetail.count', 2) do
                     put :update, :id => 1, :issue => {:project_id => '1',
                                                      :tracker_id => '2',
                                                      :priority_id => '6'
                                                     }
                   end
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue = Issue.find(1)
                 assert_equal 1, issue.project_id
                 assert_equal 2, issue.tracker_id
                 assert_equal 6, issue.priority_id
                 assert_equal 1, issue.category_id
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert mail.subject.starts_with?("[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}]")
                 assert mail.body.include?("Tracker changed from Bug to Feature request")
               end
               def test_put_update_with_custom_field_change
                 @request.session[:user_id] = 2
                 issue = Issue.find(1)
                 assert_equal '125', issue.custom_value_for(2).value
                 assert_difference('Journal.count') do
                   assert_difference('JournalDetail.count', 3) do
                     put :update, :id => 1, :issue => {:subject => 'Custom field change',
                                                      :priority_id => '6',
                                                      :category_id => '1', # no change
                                                      :custom_field_values => { '2' => 'New custom value' }
                                                     }
                   end
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert_equal 'New custom value', issue.custom_value_for(2).value
                 mail = ActionMailer::Base.deliveries.last
                 assert_kind_of TMail::Mail, mail
                 assert mail.body.include?("Searchable field changed from 125 to New custom value")
               end
               def test_put_update_with_status_and_assignee_change
                 issue = Issue.find(1)
                 assert_equal 1, issue.status_id
                 @request.session[:user_id] = 2
                 assert_difference('TimeEntry.count', 0) do
                   put :update,
                        :id => 1,
                        :issue => { :status_id => 2, :assigned_to_id => 3 },
                        :notes => 'Assigned to dlopper',
                        :time_entry => { :hours => '', :comments => '', :activity_id => TimeEntryActivity.first }
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert_equal 2, issue.status_id
                 j = Journal.find(:first, :order => 'id DESC')
                 assert_equal 'Assigned to dlopper', j.notes
                 assert_equal 2, j.details.size
                 mail = ActionMailer::Base.deliveries.last
                 assert mail.body.include?("Status changed from New to Assigned")
                 # subject should contain the new status
                 assert mail.subject.include?("(#{ IssueStatus.find(2).name })")
               end
               def test_put_update_with_note_only
                 notes = 'Note added by IssuesControllerTest#test_update_with_note_only'
                 # anonymous user
                 put :update,
                      :id => 1,
                      :notes => notes
                 assert_redirected_to :action => 'show', :id => '1'
                 j = Journal.find(:first, :order => 'id DESC')
                 assert_equal notes, j.notes
                 assert_equal 0, j.details.size
                 assert_equal User.anonymous, j.user
                 mail = ActionMailer::Base.deliveries.last
                 assert mail.body.include?(notes)
               end
               def test_put_update_with_note_and_spent_time
                 @request.session[:user_id] = 2
                 spent_hours_before = Issue.find(1).spent_hours
                 assert_difference('TimeEntry.count') do
                   put :update,
                        :id => 1,
                        :notes => '2.5 hours added',
                        :time_entry => { :hours => '2.5', :comments => 'test_put_update_with_note_and_spent_time', :activity_id => TimeEntryActivity.first.id }
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue = Issue.find(1)
                 j = Journal.find(:first, :order => 'id DESC')
                 assert_equal '2.5 hours added', j.notes
                 assert_equal 0, j.details.size
                 t = issue.time_entries.find_by_comments('test_put_update_with_note_and_spent_time')
                 assert_not_nil t
                 assert_equal 2.5, t.hours
                 assert_equal spent_hours_before + 2.5, issue.spent_hours
               end
               def test_put_update_with_attachment_only
                 set_tmp_attachments_directory
                 # Delete all fixtured journals, a race condition can occur causing the wrong
                 # journal to get fetched in the next find.
                 Journal.delete_all
                 # anonymous user
                 assert_difference 'Attachment.count' do
                   put :update, :id => 1,
                     :notes => '',
                     :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 j = Issue.find(1).journals.find(:first, :order => 'id DESC')
                 assert j.notes.blank?
                 assert_equal 1, j.details.size
                 assert_equal 'testfile.txt', j.details.first.value
                 assert_equal User.anonymous, j.user
                 attachment = Attachment.first(:order => 'id DESC')
                 assert_equal Issue.find(1), attachment.container
                 assert_equal User.anonymous, attachment.author
                 assert_equal 'testfile.txt', attachment.filename
                 assert_equal 'text/plain', attachment.content_type
                 assert_equal 'test file', attachment.description
                 assert_equal 59, attachment.filesize
                 assert File.exists?(attachment.diskfile)
                 assert_equal 59, File.size(attachment.diskfile)
                 mail = ActionMailer::Base.deliveries.last
                 assert mail.body.include?('testfile.txt')
               end
               def test_put_update_with_attachment_that_fails_to_save
                 set_tmp_attachments_directory
                 # Delete all fixtured journals, a race condition can occur causing the wrong
                 # journal to get fetched in the next find.
                 Journal.delete_all
                 # Mock out the unsaved attachment
                 Attachment.any_instance.stubs(:create).returns(Attachment.new)
                 # anonymous user
                 put :update,
                      :id => 1,
                      :notes => '',
                      :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                 assert_redirected_to :action => 'show', :id => '1'
                 assert_equal '1 file(s) could not be saved.', flash[:warning]
               end if Object.const_defined?(:Mocha)
               def test_put_update_with_no_change
                 issue = Issue.find(1)
                 issue.journals.clear
                 ActionMailer::Base.deliveries.clear
                 put :update,
                      :id => 1,
                      :notes => ''
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert issue.journals.empty?
                 # No email should be sent
                 assert ActionMailer::Base.deliveries.empty?
               end
               def test_put_update_should_send_a_notification
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 issue = Issue.find(1)
                 old_subject = issue.subject
                 new_subject = 'Subject modified by IssuesControllerTest#test_post_edit'
                 put :update, :id => 1, :issue => {:subject => new_subject,
                                                  :priority_id => '6',
                                                  :category_id => '1' # no change
                                                 }
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_put_update_with_invalid_spent_time_hours_only
                 @request.session[:user_id] = 2
                 notes = 'Note added by IssuesControllerTest#test_post_edit_with_invalid_spent_time'
                 assert_no_difference('Journal.count') do
                   put :update,
                        :id => 1,
                        :notes => notes,
                        :time_entry => {"comments"=>"", "activity_id"=>"", "hours"=>"2z"}
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_error_tag :descendant => {:content => /Activity can't be blank/}
                 assert_tag :textarea, :attributes => { :name => 'notes' }, :content => notes
                 assert_tag :input, :attributes => { :name => 'time_entry[hours]', :value => "2z" }
               end
               def test_put_update_with_invalid_spent_time_comments_only
                 @request.session[:user_id] = 2
                 notes = 'Note added by IssuesControllerTest#test_post_edit_with_invalid_spent_time'
                 assert_no_difference('Journal.count') do
                   put :update,
                        :id => 1,
                        :notes => notes,
                        :time_entry => {"comments"=>"this is my comment", "activity_id"=>"", "hours"=>""}
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_error_tag :descendant => {:content => /Activity can't be blank/}
                 assert_error_tag :descendant => {:content => /Hours can't be blank/}
                 assert_tag :textarea, :attributes => { :name => 'notes' }, :content => notes
                 assert_tag :input, :attributes => { :name => 'time_entry[comments]', :value => "this is my comment" }
               end
               def test_put_update_should_allow_fixed_version_to_be_set_to_a_subproject
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 put :update,
                      :id => issue.id,
                      :issue => {
                        :fixed_version_id => 4
                      }
                 assert_response :redirect
                 issue.reload
                 assert_equal 4, issue.fixed_version_id
                 assert_not_equal issue.project_id, issue.fixed_version.project_id
               end
               def test_put_update_should_redirect_back_using_the_back_url_parameter
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 put :update,
                      :id => issue.id,
                      :issue => {
                        :fixed_version_id => 4
                      },
                      :back_url => '/issues'
                 assert_response :redirect
                 assert_redirected_to '/issues'
               end
               def test_put_update_should_not_redirect_back_using_the_back_url_parameter_off_the_host
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 put :update,
                      :id => issue.id,
                      :issue => {
                        :fixed_version_id => 4
                      },
                      :back_url => 'http://google.com'
                 assert_response :redirect
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => issue.id
               end
               def test_get_bulk_edit
                 @request.session[:user_id] = 2
                 get :bulk_edit, :ids => [1, 2]
                 assert_response :success
                 assert_template 'bulk_edit'
                 assert_tag :select, :attributes => {:name => 'issue[project_id]'}
                 assert_tag :input, :attributes => {:name => 'issue[parent_issue_id]'}
                 # Project specific custom field, date type
                 field = CustomField.find(9)
                 assert !field.is_for_all?
                 assert_equal 'date', field.field_format
                 assert_tag :input, :attributes => {:name => 'issue[custom_field_values][9]'}
                 # System wide custom field
                 assert CustomField.find(1).is_for_all?
                 assert_tag :select, :attributes => {:name => 'issue[custom_field_values][1]'}
                 # Be sure we don't display inactive IssuePriorities
                 assert ! IssuePriority.find(15).active?
                 assert_no_tag :option, :attributes => {:value => '15'},
                                        :parent => {:tag => 'select', :attributes => {:id => 'issue_priority_id'} }
               end
               def test_get_bulk_edit_on_different_projects
                 @request.session[:user_id] = 2
                 get :bulk_edit, :ids => [1, 2, 6]
                 assert_response :success
                 assert_template 'bulk_edit'
                 # Can not set issues from different projects as children of an issue
                 assert_no_tag :input, :attributes => {:name => 'issue[parent_issue_id]'}
                 # Project specific custom field, date type
                 field = CustomField.find(9)
                 assert !field.is_for_all?
                 assert !field.project_ids.include?(Issue.find(6).project_id)
                 assert_no_tag :input, :attributes => {:name => 'issue[custom_field_values][9]'}
               end
               def test_get_bulk_edit_with_user_custom_field
                 field = IssueCustomField.create!(:name => 'Tester', :field_format => 'user', :is_for_all => true)
                 @request.session[:user_id] = 2
                 get :bulk_edit, :ids => [1, 2]
                 assert_response :success
                 assert_template 'bulk_edit'
                 assert_tag :select,
                   :attributes => {:name => "issue[custom_field_values][#{field.id}]"},
                   :children => {
                     :only => {:tag => 'option'},
                     :count => Project.find(1).users.count + 1
                   }
               end
               def test_get_bulk_edit_with_version_custom_field
                 field = IssueCustomField.create!(:name => 'Affected version', :field_format => 'version', :is_for_all => true)
                 @request.session[:user_id] = 2
                 get :bulk_edit, :ids => [1, 2]
                 assert_response :success
                 assert_template 'bulk_edit'
                 assert_tag :select,
                   :attributes => {:name => "issue[custom_field_values][#{field.id}]"},
                   :children => {
                     :only => {:tag => 'option'},
                     :count => Project.find(1).shared_versions.count + 1
                   }
               end
               def test_bulk_update
                 @request.session[:user_id] = 2
                 # update issues priority
                 post :bulk_update, :ids => [1, 2], :notes => 'Bulk editing',
                                                  :issue => {:priority_id => 7,
                                                             :assigned_to_id => '',
                                                             :custom_field_values => {'2' => ''}}
                 assert_response 302
                 # check that the issues were updated
                 assert_equal [7, 7], Issue.find_all_by_id([1, 2]).collect {|i| i.priority.id}
                 issue = Issue.find(1)
                 journal = issue.journals.find(:first, :order => 'created_on DESC')
                 assert_equal '125', issue.custom_value_for(2).value
                 assert_equal 'Bulk editing', journal.notes
                 assert_equal 1, journal.details.size
               end
               def test_bulk_update_with_group_assignee
                 group = Group.find(11)
                 project = Project.find(1)
                 project.members << Member.new(:principal => group, :roles => [Role.first])
                 @request.session[:user_id] = 2
                 # update issues assignee
                 post :bulk_update, :ids => [1, 2], :notes => 'Bulk editing',
                                                  :issue => {:priority_id => '',
                                                             :assigned_to_id => group.id,
                                                             :custom_field_values => {'2' => ''}}
                 assert_response 302
                 assert_equal [group, group], Issue.find_all_by_id([1, 2]).collect {|i| i.assigned_to}
               end
               def test_bulk_update_on_different_projects
                 @request.session[:user_id] = 2
                 # update issues priority
                 post :bulk_update, :ids => [1, 2, 6], :notes => 'Bulk editing',
                                                  :issue => {:priority_id => 7,
                                                             :assigned_to_id => '',
                                                             :custom_field_values => {'2' => ''}}
                 assert_response 302
                 # check that the issues were updated
                 assert_equal [7, 7, 7], Issue.find([1,2,6]).map(&:priority_id)
                 issue = Issue.find(1)
                 journal = issue.journals.find(:first, :order => 'created_on DESC')
                 assert_equal '125', issue.custom_value_for(2).value
                 assert_equal 'Bulk editing', journal.notes
                 assert_equal 1, journal.details.size
               end
               def test_bulk_update_on_different_projects_without_rights
                 @request.session[:user_id] = 3
                 user = User.find(3)
                 action = { :controller => "issues", :action => "bulk_update" }
                 assert user.allowed_to?(action, Issue.find(1).project)
                 assert ! user.allowed_to?(action, Issue.find(6).project)
                 post :bulk_update, :ids => [1, 6], :notes => 'Bulk should fail',
                                                  :issue => {:priority_id => 7,
                                                             :assigned_to_id => '',
                                                             :custom_field_values => {'2' => ''}}
                 assert_response 403
                 assert_not_equal "Bulk should fail", Journal.last.notes
               end
               def test_bullk_update_should_send_a_notification
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 post(:bulk_update,
                      {
                        :ids => [1, 2],
                        :notes => 'Bulk editing',
                        :issue => {
                          :priority_id => 7,
                          :assigned_to_id => '',
                          :custom_field_values => {'2' => ''}
                        }
                      })
                 assert_response 302
                 assert_equal 2, ActionMailer::Base.deliveries.size
               end
               def test_bulk_update_project
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1, 2], :issue => {:project_id => '2'}
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook'
                 # Issues moved to project 2
                 assert_equal 2, Issue.find(1).project_id
                 assert_equal 2, Issue.find(2).project_id
                 # No tracker change
                 assert_equal 1, Issue.find(1).tracker_id
                 assert_equal 2, Issue.find(2).tracker_id
               end
               def test_bulk_update_project_on_single_issue_should_follow_when_needed
                 @request.session[:user_id] = 2
                 post :bulk_update, :id => 1, :issue => {:project_id => '2'}, :follow => '1'
                 assert_redirected_to '/issues/1'
               end
               def test_bulk_update_project_on_multiple_issues_should_follow_when_needed
                 @request.session[:user_id] = 2
                 post :bulk_update, :id => [1, 2], :issue => {:project_id => '2'}, :follow => '1'
                 assert_redirected_to '/projects/onlinestore/issues'
               end
               def test_bulk_update_tracker
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1, 2], :issue => {:tracker_id => '2'}
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook'
                 assert_equal 2, Issue.find(1).tracker_id
                 assert_equal 2, Issue.find(2).tracker_id
               end
               def test_bulk_update_status
                 @request.session[:user_id] = 2
                 # update issues priority
                 post :bulk_update, :ids => [1, 2], :notes => 'Bulk editing status',
                                                  :issue => {:priority_id => '',
                                                             :assigned_to_id => '',
                                                             :status_id => '5'}
                 assert_response 302
                 issue = Issue.find(1)
                 assert issue.closed?
               end
               def test_bulk_update_priority
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1, 2], :issue => {:priority_id => 6}
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook'
                 assert_equal 6, Issue.find(1).priority_id
                 assert_equal 6, Issue.find(2).priority_id
               end
               def test_bulk_update_with_notes
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1, 2], :notes => 'Moving two issues'
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook'
                 assert_equal 'Moving two issues', Issue.find(1).journals.sort_by(&:id).last.notes
                 assert_equal 'Moving two issues', Issue.find(2).journals.sort_by(&:id).last.notes
               end
               def test_bulk_update_parent_id
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1, 3],
                   :notes => 'Bulk editing parent',
                   :issue => {:priority_id => '', :assigned_to_id => '', :status_id => '', :parent_issue_id => '2'}
                 assert_response 302
                 parent = Issue.find(2)
                 assert_equal parent.id, Issue.find(1).parent_id
                 assert_equal parent.id, Issue.find(3).parent_id
                 assert_equal [1, 3], parent.children.collect(&:id).sort
               end
               def test_bulk_update_custom_field
                 @request.session[:user_id] = 2
                 # update issues priority
                 post :bulk_update, :ids => [1, 2], :notes => 'Bulk editing custom field',
                                                  :issue => {:priority_id => '',
                                                             :assigned_to_id => '',
                                                             :custom_field_values => {'2' => '777'}}
                 assert_response 302
                 issue = Issue.find(1)
                 journal = issue.journals.find(:first, :order => 'created_on DESC')
                 assert_equal '777', issue.custom_value_for(2).value
                 assert_equal 1, journal.details.size
                 assert_equal '125', journal.details.first.old_value
                 assert_equal '777', journal.details.first.value
               end
               def test_bulk_update_unassign
                 assert_not_nil Issue.find(2).assigned_to
                 @request.session[:user_id] = 2
                 # unassign issues
                 post :bulk_update, :ids => [1, 2], :notes => 'Bulk unassigning', :issue => {:assigned_to_id => 'none'}
                 assert_response 302
                 # check that the issues were updated
                 assert_nil Issue.find(2).assigned_to
               end
               def test_post_bulk_update_should_allow_fixed_version_to_be_set_to_a_subproject
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1,2], :issue => {:fixed_version_id => 4}
                 assert_response :redirect
                 issues = Issue.find([1,2])
                 issues.each do |issue|
                   assert_equal 4, issue.fixed_version_id
                   assert_not_equal issue.project_id, issue.fixed_version.project_id
                 end
               end
               def test_post_bulk_update_should_redirect_back_using_the_back_url_parameter
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1,2], :back_url => '/issues'
                 assert_response :redirect
                 assert_redirected_to '/issues'
               end
               def test_post_bulk_update_should_not_redirect_back_using_the_back_url_parameter_off_the_host
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1,2], :back_url => 'http://google.com'
                 assert_response :redirect
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => Project.find(1).identifier
               end
+              def test_bulk_copy_to_another_project
+                @request.session[:user_id] = 2
+                assert_difference 'Issue.count', 2 do
+                  assert_no_difference 'Project.find(1).issues.count' do
+                    post :bulk_update, :ids => [1, 2], :issue => {:project_id => '2'}, :copy => '1'
+                  end
+                end
+                assert_redirected_to '/projects/ecookbook/issues'
+              end
+              def test_bulk_copy_should_allow_not_changing_the issue_attributes
+                @request.session[:user_id] = 2
+                issue_before_move = Issue.find(1)
+                assert_difference 'Issue.count', 1 do
+                  assert_no_difference 'Project.find(1).issues.count' do
+                    post :bulk_update, :ids => [1], :copy => '1',
+                         :issue => {
+                           :project_id => '2', :tracker_id => '', :assigned_to_id => '',
+                           :status_id => '', :start_date => '', :due_date => ''
+                         }
+                  end
+                end
+                issue_after_move = Issue.first(:order => 'id desc', :conditions => {:project_id => 2})
+                assert_equal issue_before_move.tracker_id, issue_after_move.tracker_id
+                assert_equal issue_before_move.status_id, issue_after_move.status_id
+                assert_equal issue_before_move.assigned_to_id, issue_after_move.assigned_to_id
+              end
+             def test_bulk_copy_should_allow_changing_the_issue_attributes
+                # Fixes random test failure with Mysql
+                # where Issue.all(:limit => 2, :order => 'id desc', :conditions => {:project_id => 2})
+                # doesn't return the expected results
+                Issue.delete_all("project_id=2")
+                @request.session[:user_id] = 2
+                assert_difference 'Issue.count', 2 do
+                  assert_no_difference 'Project.find(1).issues.count' do
+                    post :bulk_update, :ids => [1, 2], :copy => '1',
+                         :issue => {
+                           :project_id => '2', :tracker_id => '', :assigned_to_id => '4',
+                           :status_id => '3', :start_date => '2009-12-01', :due_date => '2009-12-31'
+                         }
+                  end
+                end
+                copied_issues = Issue.all(:limit => 2, :order => 'id desc', :conditions => {:project_id => 2})
+                assert_equal 2, copied_issues.size
+                copied_issues.each do |issue|
+                  assert_equal 2, issue.project_id, "Project is incorrect"
+                  assert_equal 4, issue.assigned_to_id, "Assigned to is incorrect"
+                  assert_equal 3, issue.status_id, "Status is incorrect"
+                  assert_equal '2009-12-01', issue.start_date.to_s, "Start date is incorrect"
+                  assert_equal '2009-12-31', issue.due_date.to_s, "Due date is incorrect"
+                end
+              end
+              def test_bulk_copy_should_allow_adding_a_note
+                @request.session[:user_id] = 2
+                assert_difference 'Issue.count', 1 do
+                  post :bulk_update, :ids => [1], :copy => '1',
+                       :notes => 'Copying one issue',
+                       :issue => {
+                         :project_id => '', :tracker_id => '', :assigned_to_id => '4',
+                         :status_id => '3', :start_date => '2009-12-01', :due_date => '2009-12-31'
+                       }
+                end
+                issue = Issue.first(:order => 'id DESC')
+                assert_equal 1, issue.journals.size
+                journal = issue.journals.first
+                assert_equal 0, journal.details.size
+                assert_equal 'Copying one issue', journal.notes
+              end
+              def test_bulk_copy_to_another_project_should_follow_when_needed
+                @request.session[:user_id] = 2
+                post :bulk_update, :ids => [1], :copy => '1', :issue => {:project_id => 2}, :follow => '1'
+                issue = Issue.first(:order => 'id DESC')
+                assert_redirected_to :controller => 'issues', :action => 'show', :id => issue
+              end
               def test_destroy_issue_with_no_time_entries
                 assert_nil TimeEntry.find_by_issue_id(2)
                 @request.session[:user_id] = 2
                 delete :destroy, :id => 2
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil Issue.find_by_id(2)
               end
               def test_destroy_issues_with_time_entries
                 @request.session[:user_id] = 2
                 delete :destroy, :ids => [1, 3]
                 assert_response :success
                 assert_template 'destroy'
                 assert_not_nil assigns(:hours)
                 assert Issue.find_by_id(1) && Issue.find_by_id(3)
               end
               def test_destroy_issues_and_destroy_time_entries
                 @request.session[:user_id] = 2
                 delete :destroy, :ids => [1, 3], :todo => 'destroy'
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                 assert_nil TimeEntry.find_by_id([1, 2])
               end
               def test_destroy_issues_and_assign_time_entries_to_project
                 @request.session[:user_id] = 2
                 delete :destroy, :ids => [1, 3], :todo => 'nullify'
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                 assert_nil TimeEntry.find(1).issue_id
                 assert_nil TimeEntry.find(2).issue_id
               end
               def test_destroy_issues_and_reassign_time_entries_to_another_issue
                 @request.session[:user_id] = 2
                 delete :destroy, :ids => [1, 3], :todo => 'reassign', :reassign_to_id => 2
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                 assert_equal 2, TimeEntry.find(1).issue_id
                 assert_equal 2, TimeEntry.find(2).issue_id
               end
               def test_destroy_issues_from_different_projects
                 @request.session[:user_id] = 2
                 delete :destroy, :ids => [1, 2, 6], :todo => 'destroy'
                 assert_redirected_to :controller => 'issues', :action => 'index'
                 assert !(Issue.find_by_id(1) || Issue.find_by_id(2) || Issue.find_by_id(6))
               end
               def test_destroy_parent_and_child_issues
                 parent = Issue.generate!(:project_id => 1, :tracker_id => 1)
                 child = Issue.generate!(:project_id => 1, :tracker_id => 1, :parent_issue_id => parent.id)
                 assert child.is_descendant_of?(parent.reload)
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count', -2 do
                   delete :destroy, :ids => [parent.id, child.id], :todo => 'destroy'
                 end
                 assert_response 302
               end
               def test_default_search_scope
                 get :index
                 assert_tag :div, :attributes => {:id => 'quick-search'},
                                  :child => {:tag => 'form',
                                             :child => {:tag => 'input', :attributes => {:name => 'issues', :type => 'hidden', :value => '1'}}}
               end
             end

app/controllers/issue_moves_controller.rb removed 0 -85

NO CONTENT: file was removed

app/helpers/issue_moves_helper.rb removed 0 -4

NO CONTENT: file was removed

app/views/issue_moves/new.html.erb removed 0 -79

NO CONTENT: file was removed

test/functional/issue_moves_controller_test.rb removed 0 -116

NO CONTENT: file was removed

test/integration/routing/issue_moves_test.rb removed 0 -31

NO CONTENT: file was removed

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