Redmine

  def index

    retrieve_query

    if @query.valid?

                                  :limit => 25)

    end

    @title = (@project ? @project.name : Setting.app_title) + ": " + (@query.new_record? ? l(:label_changes_details) : @query.name)

  include Redmine::SafeAttributes

  belongs_to :board

  belongs_to :author, :class_name => 'User'

  acts_as_attachable

  belongs_to :last_reply, :class_name => 'Message'

  # returns latest news for projects visible by user

  def self.latest(user = User.current, count = 5)

  end

  private

  def group_by_sort_order

    if column = group_by_column

      order = (sort_criteria.order_for(column.name) || column.default_order || 'asc').try(:upcase)

    end

  end

  def self.fields_for_order_statement(table=nil)

    table ||= table_name

  end

  scope :sorted, lambda { order(fields_for_order_statement) }

  has_one :content_without_text, lambda {without_text.readonly}, :class_name => 'WikiContent', :foreign_key => 'page_id'

  acts_as_attachable :delete_permission => :delete_wiki_pages_attachments

  acts_as_watchable

  acts_as_event :title => Proc.new {|o| "#{l(:label_wiki)}: #{o.title}"},

class Mixin < ActiveRecord::Base

end

end

class TreeMixinWithoutOrder < Mixin

end

class TreeTest < Test::Unit::TestCase

  def setup

    setup_db

    @root1 = TreeMixin.create!

    assert_equal [@root_child1, @root_child2], @root_child2.self_and_siblings

    assert_equal [@root1, @root2, @root3], @root2.self_and_siblings

    assert_equal [@root1, @root2, @root3], @root3.self_and_siblings

end

class TreeTestWithEagerLoading < Test::Unit::TestCase

    teardown_db

    setup_db

    @root1 = TreeMixin.create!

    @root_child2 = TreeMixin.create! :parent_id => @root1.id

    @root2 = TreeMixin.create!

    @root3 = TreeMixin.create!

    @rc1 = RecursivelyCascadedTreeMixin.create!

    @rc3 = RecursivelyCascadedTreeMixin.create! :parent_id => @rc2.id

    @rc4 = RecursivelyCascadedTreeMixin.create! :parent_id => @rc3.id

  end

  def teardown

    teardown_db

  end

  def test_eager_association_loading

    roots = TreeMixin.find(:all, :include => :children, :conditions => "mixins.parent_id IS NULL", :order => "mixins.id")

    assert_no_queries do

      assert_equal 2, roots[0].children.size

      assert_equal 0, roots[1].children.size

      assert_equal 0, roots[2].children.size

  end

  def test_eager_association_loading_with_recursive_cascading_three_levels_has_many

    root_node = RecursivelyCascadedTreeMixin.find(:first, :include => { :children => { :children => :children } }, :order => 'mixins.id')

    assert_equal @rc4, assert_no_queries { root_node.children.first.children.first.children.first }

  end

  def test_eager_association_loading_with_recursive_cascading_three_levels_has_one

    root_node = RecursivelyCascadedTreeMixin.find(:first, :include => { :first_child => { :first_child => :first_child } }, :order => 'mixins.id')

    assert_equal @rc4, assert_no_queries { root_node.first_child.first_child.first_child }

  end

  def test_eager_association_loading_with_recursive_cascading_three_levels_belongs_to

    leaf_node = RecursivelyCascadedTreeMixin.find(:first, :include => { :parent => { :parent => :parent } }, :order => 'mixins.id DESC')

    assert_equal @rc1, assert_no_queries { leaf_node.parent.parent.parent }

end

class TreeTestWithoutOrder < Test::Unit::TestCase

    setup_db

    @root1 = TreeMixinWithoutOrder.create!

    @root2 = TreeMixinWithoutOrder.create!

  def test_root

    assert [@root1, @root2].include?(TreeMixinWithoutOrder.root)

  end

  def test_roots

    assert_equal [], [@root1, @root2] - TreeMixinWithoutOrder.roots

  end

      def issues

        @issues ||= @query.issues(

          :include => [:assigned_to, :tracker, :priority, :category, :fixed_version],

          :limit => @max_rows

        )

      end

      sql = self.collect do |k,o|

        if s = sortable_columns[k]

          s = [s] unless s.is_a?(Array)

        end

      end.flatten.compact

      sql.blank? ? nil : sql

    c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }

    assert c

    assert c.sortable

    values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}

    assert !values.empty?

    assert_equal values.sort, values

    c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }

    assert c

    assert c.sortable

    values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}

    assert !values.empty?

    assert_equal values.sort.reverse, values

    c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'float' }

    assert c

    assert c.sortable

    values = issues.collect {|i| begin; Kernel.Float(i.custom_value_for(c.custom_field).to_s); rescue; nil; end}.compact

    assert !values.empty?

    assert_equal values.sort, values

  def test_issue_ids

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

    issues = q.issues(:order => order)

    assert_equal issues.map(&:id), q.issue_ids(:order => order)

  end