Redmine

        copied = @project.copy(@source_project, :only => params[:only])

        if @project.issues_not_copied.present?

          flash[:warning] = l(:warning_issues_not_copied, @project.issues_not_copied.size)

        end

        if copied

  # Returns the issues of the source project that could not be copied

  # by the last call to #copy

  attr_reader :issues_not_copied

    @issues_not_copied = []

        @issues_not_copied << issue

        # Remove the issue that could not be saved from the association target,

        # otherwise it would make the project invalid and prevent any further save

        self.issues.target.delete(new_issue)

        # Relations between two copied issues have already been copied above

        next if issues_map[source_relation.issue_from_id]

  warning_issues_not_copied: "%{count} Ticket(s) konnten nicht kopiert werden."

  warning_issues_not_copied: "%{count} issue(s) could not be copied."

  warning_issues_not_copied: "%{count} demande(s) n'ont pas pu être copiées."

  warning_issues_not_copied: "%{count}件のチケットをコピーできませんでした。"

  def test_post_copy_should_warn_about_issues_that_could_not_be_copied

    @request.session[:user_id] = 1 # admin

    # Issues of the source project can not be copied because this required

    # custom field is blank

    IssueCustomField.generate!(:field_format => 'string', :is_required => true,

                               :is_for_all => true, :trackers => Tracker.all)

    post(

      :copy,

      :params => {

        :id => 1,

        :project => {

          :name => 'Copy',

          :identifier => 'unique-copy',

          :tracker_ids => ['1', '2', '3', ''],

          :enabled_module_names => %w(issue_tracking)

        },

        :only => %w(issues)

      }

    )

    assert_redirected_to :controller => 'projects', :action => 'settings', :id => 'unique-copy'

    project = Project.find('unique-copy')

    assert_equal 0, project.issues.count

    assert_equal l(:warning_issues_not_copied, Project.find(1).issues.count), flash[:warning]

  end

  test "#copy should keep copying when an issue cannot be copied" do

    # This issue can not be copied because the required custom field below is blank

    Issue.generate!(:project => @source_project, :tracker_id => 2,

                    :subject => 'No required value')

    IssueCustomField.generate!(:field_format => 'string', :is_required => true,

                               :is_for_all => true, :trackers => [Tracker.find(2)])

    assert @project.copy(@source_project)

    assert @project.valid?

    assert_nil @project.issues.find_by(:subject => 'No required value')

    # The other issues and objects are copied even though an issue was skipped

    assert @project.issues.any?

    assert @project.versions.any?

    assert @project.members.any?

  end

  test "#copy should report the issues that could not be copied" do

    skipped_issue =

      Issue.generate!(:project => @source_project, :tracker_id => 2,

                      :subject => 'No required value')

    IssueCustomField.generate!(:field_format => 'string', :is_required => true,

                               :is_for_all => true, :trackers => [Tracker.find(2)])

    assert @project.copy(@source_project)

    assert_equal [skipped_issue], @project.issues_not_copied

  end

  test "#copy should not report any issue when they are all copied" do

    assert @project.copy(@source_project)

    assert_equal [], @project.issues_not_copied

  end

  test "#copy should copy a relation between two copied issues only once" do

    issue = Issue.generate!(:project => @source_project, :subject => 'Relation from')

    other_issue = Issue.generate!(:project => @source_project, :subject => 'Relation to')

    IssueRelation.create!(:issue_from => issue, :issue_to => other_issue,

                          :relation_type => 'relates')

    assert @project.copy(@source_project)

    # A second copy of the relation would be rejected by the uniqueness

    # validation and would leave the copied issue invalid

    assert @project.issues.all?(&:valid?)

    assert_equal(

      1,

      IssueRelation.where(:issue_from_id => @project.issues, :issue_to_id => @project.issues).count

    )

  end