Redmine

  self.view_permission = :view_issues

  self.available_columns = [

    QueryColumn.new(:project, :sortable => "#{Project.table_name}.name", :groupable => true),

    QueryColumn.new(:tracker, :sortable => "#{Tracker.table_name}.position", :groupable => true),

    QueryColumn.new(:parent, :sortable => ["#{Issue.table_name}.root_id", "#{Issue.table_name}.lft ASC"], :default_order => 'desc', :caption => :field_parent_issue),

issue_list_default_columns:

  serialized: true

  default:

  - tracker

  - status

  - priority

      :f => [filter_name],

      :op => {filter_name => '='},

      :v => {filter_name => ['Foo']},

    assert_response :success

    assert_equal [3, 5], issues_in_list.map(&:project_id).uniq.sort

    assert_response :success

    assert_equal 'text/csv; header=present', @response.content_type

    lines = response.body.chomp.split("\n")

  end

  def test_index_csv_with_project

    issue = Issue.create!(:project_id => 1, :tracker_id => 1, :subject => 'test_index_csv_with_spent_time_column', :author_id => 2)

    TimeEntry.create!(:project => issue.project, :issue => issue, :hours => 7.33, :user => User.find(2), :spent_on => Date.today)

    assert_response :success

    assert_equal 'text/csv; header=present', @response.content_type

    lines = @response.body.chomp.split("\n")

    child = Issue.generate!(:parent_issue_id => parent.id)

    with_settings :default_language => 'en' do

    end

    lines = response.body.split("\n")

    assert_include "#{child.id},#{parent.id}", lines

      str_big5  = "\xa4@\xa4\xeb".force_encoding('Big5')

      issue = Issue.generate!(:subject => str_utf8)

                  :op => '=', :values => [str_utf8],

                  :format => 'csv'

      assert_equal 'text/csv; header=present', @response.content_type

      str_utf8  = "\xe4\xbb\xa5\xe5\x86\x85".force_encoding('UTF-8')

      issue = Issue.generate!(:subject => str_utf8)

                  :op => '=', :values => [str_utf8],

                  :format => 'csv',

                  :set_filter => 1

      assert_equal 'text/csv; header=present', @response.content_type

      str1  = "test_index_csv_tw"

      issue = Issue.generate!(:subject => str1, :estimated_hours => '1234.5')

                  :op => '=', :values => [str1],

                  :format => 'csv',

                  :set_filter => 1

      assert_equal 'text/csv; header=present', @response.content_type

      str1  = "test_index_csv_fr"

      issue = Issue.generate!(:subject => str1, :estimated_hours => '1234.5')

                  :op => '=', :values => [str1],

                  :format => 'csv',

                  :set_filter => 1

      assert_equal 'text/csv; header=present', @response.content_type

    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 = issues_in_list.map(&:assigned_to).compact

    assert_equal assignees.sort, assignees

    assert_select 'table.issues.sort-by-assigned-to.sort-asc'

  end

  def test_index_sort_by_assigned_to_desc

    get :index, :sort => 'assigned_to:desc'

    assert_response :success

    assignees = issues_in_list.map(&:assigned_to).compact

    assert_equal assignees.sort.reverse, assignees

    assert_select 'table.issues.sort-by-assigned-to.sort-desc'

  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', :c => ['author']

    assert_response :success

    authors = issues_in_list.map(&:author)

    assert_equal authors.sort, authors

  end

  def test_index_sort_by_author_desc

    get :index, :sort => 'author:desc'

    assert_response :success

    authors = issues_in_list.map(&: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 = issues_in_list.map(&:spent_hours)

    assert_equal hours.sort.reverse, hours

  end

  def test_index_sort_by_total_spent_hours

    get :index, :sort => 'total_spent_hours:desc'

    assert_response :success

    hours = issues_in_list.map(&:total_spent_hours)

    assert_equal hours.sort.reverse, hours

  end

  def test_index_sort_by_total_estimated_hours

    get :index, :sort => 'total_estimated_hours:desc'

    assert_response :success

    CustomValue.create!(:custom_field => cf, :customized => Issue.find(3), :value => '3')

    CustomValue.create!(:custom_field => cf, :customized => Issue.find(5), :value => '')

    assert_response :success

    assert_equal [2, 3, 1], issues_in_list.select {|issue| issue.custom_field_value(cf).present?}.map(&:id)

    get :index, :set_filter => 1, :c => columns

    assert_response :success

    # columns should be stored in session

    assert_kind_of Hash, session[:issue_query]

    get :index, :set_filter => 1

    # query should use specified columns

  end

  def test_index_without_project_and_explicit_default_columns_should_not_add_project_column

    with_settings :issue_list_default_columns => columns do

      get :index, :project_id => 1, :set_filter => 1

    end

  end

  def test_index_with_custom_field_column

    get :index, :set_filter => 1, :c => columns

    assert_response :success

    IssueRelation.create!(:relation_type => "blocks", :issue_from => Issue.find(1), :issue_to => Issue.find(11))

    IssueRelation.create!(:relation_type => "blocks", :issue_from => Issue.find(12), :issue_to => Issue.find(2))

    assert_response :success

    assert_select "tr#issue-1 td.relations" do

      assert_select "span", 3

      assert_select "span", 0

    end

    assert_response :success

    assert_equal 'text/csv; header=present', response.content_type

    lines = response.body.chomp.split("\n")

    assert_include '2,Blocked by #12', lines

    assert_include '3,""', lines

    assert_response :success

    assert_equal 'application/pdf', response.content_type

  end

  def test_index_with_description_column

    get :index, :set_filter => 1, :c => %w(subject description)

    get :index, :set_filter => 1, :c => %w(subject description), :format => 'pdf'

    assert_response :success

  def test_index_should_not_include_new_issue_tab_for_project_without_trackers

    with_settings :new_item_menu_tab => '1' do

      Project.find(1).trackers.clear

      @request.session[:user_id] = 2

      get :index, :project_id => 1

      assert_select '#main-menu a.new-issue', 0

      role = Role.find(1)

      role.remove_permission! :add_issues

      role.add_permission! :copy_issues

      @request.session[:user_id] = 2

      get :index, :project_id => 1

      assert_select '#main-menu a.new-issue', 0

  def test_show_should_display_prev_next_links_with_query_and_sort_on_association

    @request.session[:query] = {:filters => {'status_id' => {:values => [''], :operator => 'o'}}, :project_id => nil}

    %w(project tracker status priority author assigned_to category fixed_version).each do |assoc_sort|

      @request.session['issues_index_sort'] = assoc_sort

  end

  def test_show_export_to_pdf

    assert issue.relations.select{|r| r.other_issue(issue).visible?}.present?

    get :show, :id => 3, :format => 'pdf'

    assert_response :success

    get :new, :project_id => 'invalid'

    assert_response 404

  end

  def test_new_with_parent_id_should_only_propose_valid_trackers

    @request.session[:user_id] = 2

    t = Tracker.find(3)

                              :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

  end

        assert_select 'option[value="1"][selected=selected]', :text => 'eCookbook'

        assert_select 'option[value="2"]:not([selected])', :text => 'OnlineStore'

      end

      assert_select 'input[name=copy_from][value="1"]'

    end

  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_select 'input[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_select 'input[name=?]', 'time_entry[hours]', 0

  end

    assert_response :redirect

    assert_redirected_to :controller => 'issues', :action => 'show', :id => issue.id

  end

  def test_put_update_should_redirect_with_previous_and_next_issue_ids_params

    @request.session[:user_id] = 2

      assert_select 'select[name=?]', 'issue[project_id]'

      assert_select 'input[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_select 'input[name=?]', 'issue[custom_field_values][9]'

      # System wide custom field

      assert CustomField.find(1).is_for_all?

      assert_select 'select[name=?]', 'issue[custom_field_values][1]'

      # Be sure we don't display inactive IssuePriorities

      assert ! IssuePriority.find(15).active?

      assert_select 'select[name=?]', 'issue[priority_id]' do

                                       :issue => {:priority_id => '',

                                                  :assigned_to_id => group.id,

                                                  :custom_field_values => {'2' => ''}}

      assert_response 302

      assert_equal [group, group], Issue.where(:id => [1, 2]).collect {|i| i.assigned_to}

    end

      assert_select 'option[value="2"]'

    end

  end

  def test_bulk_copy_to_another_project

    @request.session[:user_id] = 2

    assert_difference 'Issue.count', 2 do

                    :assigned_to_id => 3)

    ]

    assert_difference 'Issue.count', issues.size do

           :issue => {

             :project_id => '', :tracker_id => '', :assigned_to_id => '',

             :status_id => '', :start_date => '', :due_date => ''

    @request.session[:user_id] = 2

    assert_difference 'Issue.count', 2 do

      assert_no_difference 'Project.find(1).issues.count' do

             :issue => {

               :project_id => '2', :tracker_id => '', :assigned_to_id => '2',

               :status_id => '1', :start_date => '2009-12-01', :due_date => '2009-12-31'

    Issue.generate!(:project => p1, :tracker_id => 1, :custom_field_values => {@field2.id => 'ValueC'})

    @request.session[:user_id] = user.id

    assert_select 'td', :text => 'ValueA'

    assert_select 'td', :text => 'ValueB', :count => 0

    assert_select 'td', :text => 'ValueC'

         :operators => {"assigned_to_id" => "=", "status_id" => "o"},

         :values => { "assigned_to_id" => ["me"], "status_id" => ["1"]},

         :query => {"name" => "test_new_global_private_query", "visibility" => "0"},

    q = Query.find_by_name('test_new_global_private_query')

    assert_redirected_to :controller => 'issues', :action => 'index', :project_id => nil, :query_id => q

  def test_filter_on_parent

    Issue.delete_all

    parent = Issue.generate_with_descendants!

    query = IssueQuery.new(:name => '_')

    query.filters = {"parent_id" => {:operator => '=', :values => [parent.id.to_s]}}

    parent = Issue.generate_with_descendants!

    child, leaf = parent.children.sort_by(&:id)

    grandchild = child.children.first

    query = IssueQuery.new(:name => '_')

    query.filters = {"child_id" => {:operator => '=', :values => [grandchild.id.to_s]}}

  def test_set_column_names

    q = IssueQuery.new

    assert_equal [:id, :tracker, :subject], q.columns.collect {|c| c.name}

  end

  def test_inline_and_block_columns

    q = IssueQuery.new

    assert_equal [:id, :subject, :tracker], q.inline_columns.map(&:name)

    assert_equal [:description], q.block_columns.map(&:name)