SoundSoftware Code Site

#

# 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.

  def setup

    @project = Project.find(1)

  end

  def test_activity_without_subprojects

    events = find_events(User.anonymous, :project => @project)

    assert_not_nil events

    assert events.include?(Issue.find(1))

    assert !events.include?(Issue.find(4))

    # subproject issue

  def test_activity_with_subprojects

    events = find_events(User.anonymous, :project => @project, :with_subprojects => 1)

    assert_not_nil events

    assert events.include?(Issue.find(1))

    # subproject issue

    assert events.include?(Issue.find(5))

  end

  def test_global_activity_anonymous

    events = find_events(User.anonymous)

    assert_not_nil events

    assert events.include?(Issue.find(1))

    assert events.include?(Message.find(5))

    # Issue of a private project

    assert !events.include?(Issue.find(4))

  end

  def test_global_activity_logged_user

    events = find_events(User.find(2)) # manager

    assert_not_nil events

    assert events.include?(Issue.find(1))

    # Issue of a private project the user belongs to

    assert events.include?(Issue.find(4))

  end

  def test_user_activity

    user = User.find(2)

    events = Redmine::Activity::Fetcher.new(User.anonymous, :author => user).events(nil, nil, :limit => 10)

    assert(events.size > 0)

    assert(events.size <= 10)

    assert_nil(events.detect {|e| e.event_author != user})

  end

  def test_files_activity

    f = Redmine::Activity::Fetcher.new(User.anonymous, :project => Project.find(1))

    f.scope = ['files']

    events = f.events

    assert_kind_of Array, events

    assert events.include?(Attachment.find_by_container_type_and_container_id('Project', 1))

    assert events.include?(Attachment.find_by_container_type_and_container_id('Version', 1))

    assert_equal [Attachment], events.collect(&:class).uniq

    assert_equal %w(Project Version), events.collect(&:container_type).uniq.sort

  end

  private

  def find_events(user, options={})

    Redmine::Activity::Fetcher.new(user, options).events(Date.today - 30, Date.today + 1)

  end

# encoding: utf-8

#

#

# 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 AttachmentTest < ActiveSupport::TestCase

  fixtures :issues, :users

  def setup

  end

    assert_equal '1478adae0d4eb06d35897518540e25d6', a.digest

    assert File.exist?(a.diskfile)

  end

  def test_create_should_auto_assign_content_type

    a = Attachment.new(:container => Issue.find(1),

                       :file => uploaded_test_file("testfile.txt", ""),

    assert a.save

    assert_equal 'text/plain', a.content_type

  end

  def test_identical_attachments_at_the_same_time_should_not_overwrite

    a1 = Attachment.create!(:container => Issue.find(1),

                            :file => uploaded_test_file("testfile.txt", ""),

                            :author => User.find(1))

    assert a1.disk_filename != a2.disk_filename

  end

  def test_diskfilename

    assert Attachment.disk_filename("test_file.txt") =~ /^\d{12}_test_file.txt$/

    assert_equal 'test_file.txt', Attachment.disk_filename("test_file.txt")[13..-1]

require File.expand_path('../../test_helper', __FILE__)

class ChangesetTest < ActiveSupport::TestCase

  def setup

  end

  def test_ref_keywords_any

    ActionMailer::Base.deliveries.clear

    Setting.commit_fix_done_ratio = '90'

    Setting.commit_ref_keywords = '*'

    Setting.commit_fix_keywords = 'fixes , closes'

                      :committed_on => Time.now,

    c.scan_comment_for_issue_ids

    assert_equal [1, 2], c.issue_ids.sort

    fixed = Issue.find(1)

    assert fixed.closed?

    assert_equal 90, fixed.done_ratio

    assert_equal 1, ActionMailer::Base.deliveries.size

  end

  def test_ref_keywords

    Setting.commit_ref_keywords = 'refs'

    Setting.commit_fix_keywords = ''

                      :committed_on => Time.now,

    c.scan_comment_for_issue_ids

    assert_equal [1], c.issue_ids.sort

  end

  def test_ref_keywords_any_only

    Setting.commit_ref_keywords = '*'

    Setting.commit_fix_keywords = ''

                      :committed_on => Time.now,

    c.scan_comment_for_issue_ids

    assert_equal [1, 2], c.issue_ids.sort

  end

  def test_ref_keywords_any_with_timelog

    Setting.commit_ref_keywords = '*'

    Setting.commit_logtime_enabled = '1'

      '3,25' => 3.25,

      '3,25h' => 3.25,

    }.each do |syntax, expected_hours|

                        :committed_on => 24.hours.ago,

      assert_difference 'TimeEntry.count' do

        c.scan_comment_for_issue_ids

      end

      assert_equal [1], c.issue_ids.sort

      time = TimeEntry.first(:order => 'id desc')

      assert_equal 1, time.issue_id

      assert_equal 1, time.project_id

      assert_equal 2, time.user_id

      assert_equal Date.yesterday, time.spent_on

      assert time.activity.is_default?

    end

  end

  def test_ref_keywords_closing_with_timelog

    Setting.commit_ref_keywords = '*'

    Setting.commit_fix_keywords = 'fixes , closes'

    Setting.commit_logtime_enabled = '1'

                      :committed_on => Time.now,

    assert_difference 'TimeEntry.count', 2 do

      c.scan_comment_for_issue_ids

    end

    assert_equal [1, 2], c.issue_ids.sort

    assert Issue.find(1).closed?

    assert Issue.find(2).closed?

    times = TimeEntry.all(:order => 'id desc', :limit => 2)

    assert_equal [1, 2], times.collect(&:issue_id).sort

  end

  def test_ref_keywords_any_line_start

    Setting.commit_ref_keywords = '*'

                      :committed_on => Time.now,

    c.scan_comment_for_issue_ids

    assert_equal [1], c.issue_ids.sort

  def test_ref_keywords_allow_brackets_around_a_issue_number

    Setting.commit_ref_keywords = '*'

                      :committed_on => Time.now,

    c.scan_comment_for_issue_ids

    assert_equal [1], c.issue_ids.sort

  def test_ref_keywords_allow_brackets_around_multiple_issue_numbers

    Setting.commit_ref_keywords = '*'

                      :committed_on => Time.now,

    c.scan_comment_for_issue_ids

    assert_equal [1,2,3], c.issue_ids.sort

  end

  def test_commit_referencing_a_subproject_issue

                      :committed_on => Time.now,

    c.scan_comment_for_issue_ids

    assert_equal [5], c.issue_ids.sort

    assert c.issues.first.project != c.project

  end

  def test_commit_referencing_a_parent_project_issue

    # repository of child project

                      :committed_on => Time.now,

    c.scan_comment_for_issue_ids

    assert_equal [2], c.issue_ids.sort

    assert c.issues.first.project != c.project

  end

  end

  def test_text_tag_hash

    assert_equal 'commit:7234cb2750b63f47bff735edc50a1c0a433c2518', c.text_tag

  end

  end

  def test_comments_should_be_converted_to_utf8

            :log_encoding => 'ISO-8859-1' )

  end

            :log_encoding => 'UTF-8' )

  end

  def test_comments_should_be_converted_all_latin1_to_utf8

            :log_encoding => 'ISO-8859-1' )

  end

  def test_identifier

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

    @news.reload

    assert_equal 2, @news.comments_count

  end

  def test_validate

    comment = Comment.new(:commented => @news)

#

# 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 DefaultDataTest < ActiveSupport::TestCase

  include Redmine::I18n

  fixtures :roles

  def test_no_data

    assert !Redmine::DefaultData::Loader::no_data?

    Role.delete_all("builtin = 0")

    Enumeration.delete_all

    assert Redmine::DefaultData::Loader::no_data?

  end

  def test_load

    valid_languages.each do |lang|

      begin

#

# 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.

  def test_should_be_an_enumeration

    assert DocumentCategory.ancestors.include?(Enumeration)

  end

  def test_objects_count

    assert_equal 2, DocumentCategory.find_by_name("Uncategorized").objects_count

    assert_equal 0, DocumentCategory.find_by_name("User documentation").objects_count

    assert_equal :enumeration_doc_categories, DocumentCategory.new.option_name

  end

end

# Redmine - project management software

#

# 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.

    doc = Document.new(:project => Project.find(1), :title => 'New document', :category => Enumeration.find_by_name('User documentation'))

    assert doc.save

  end

  def test_create_should_send_email_notification

    ActionMailer::Base.deliveries.clear

    Setting.notified_events << 'document_added'

    # Sets a default category

    e = Enumeration.find_by_name('Technical documentation')

    e.update_attributes(:is_default => true)

    doc = Document.new(:project => Project.find(1), :title => 'New document')

    assert_equal e, doc.category

    assert doc.save

  end

  def test_updated_on_with_attachments

    d = Document.find(1)

    assert d.attachments.any?

    assert_equal d.attachments.map(&:created_on).max, d.updated_on

  end

  def test_updated_on_without_attachments

    d = Document.find(2)

    assert d.attachments.empty?

# Redmine - project management software

#

# 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 EnabledModuleTest < ActiveSupport::TestCase

  fixtures :projects, :wikis

  def test_enabling_wiki_should_create_a_wiki

    CustomField.delete_all

    project = Project.create!(:name => 'Project with wiki', :identifier => 'wikiproject')

    assert_not_nil project.wiki

    assert_equal 'Wiki', project.wiki.start_page

  end

  def test_reenabling_wiki_should_not_create_another_wiki

    project = Project.find(1)

    assert_not_nil project.wiki

#

# 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.

  fixtures :projects, :users, :members, :member_roles, :roles,

           :trackers, :projects_trackers,

           :versions,

           :enumerations,

           :issues,

           :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,

           :time_entries

  self.use_transactional_fixtures = false

  def test_create_root_issue

    issue1 = create_issue!

    issue2 = create_issue!

    issue1.reload

    issue2.reload

    assert_equal [issue1.id, nil, 1, 2], [issue1.root_id, issue1.parent_id, issue1.lft, issue1.rgt]

    assert_equal [issue2.id, nil, 1, 2], [issue2.root_id, issue2.parent_id, issue2.lft, issue2.rgt]

  end

  def test_create_child_issue

    parent = create_issue!

    child =  create_issue!(:parent_issue_id => parent.id)

    parent.reload

    child.reload

    assert_equal [parent.id, nil, 1, 4], [parent.root_id, parent.parent_id, parent.lft, parent.rgt]

    assert_equal [parent.id, parent.id, 2, 3], [child.root_id, child.parent_id, child.lft, child.rgt]

  end

  def test_creating_a_child_in_different_project_should_not_validate

    issue = create_issue!

    child = Issue.new(:project_id => 2, :tracker_id => 1, :author_id => 1, :subject => 'child', :parent_issue_id => issue.id)

    assert !child.save

    assert_not_nil child.errors.on(:parent_issue_id)

  end

  def test_move_a_root_to_child

    parent1 = create_issue!

    parent2 = create_issue!

    child = create_issue!(:parent_issue_id => parent1.id)

    parent2.parent_issue_id = parent1.id

    parent2.save!

    child.reload

    parent1.reload

    parent2.reload

    assert_equal [parent1.id, 1, 6], [parent1.root_id, parent1.lft, parent1.rgt]

    assert_equal [parent1.id, 4, 5], [parent2.root_id, parent2.lft, parent2.rgt]

    assert_equal [parent1.id, 2, 3], [child.root_id, child.lft, child.rgt]

  end

  def test_move_a_child_to_root

    parent1 = create_issue!

    parent2 = create_issue!

    child =   create_issue!(:parent_issue_id => parent1.id)

    child.parent_issue_id = nil

    child.save!

    child.reload

    parent1.reload

    parent2.reload

    assert_equal [parent1.id, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]

    assert_equal [parent2.id, 1, 2], [parent2.root_id, parent2.lft, parent2.rgt]

    assert_equal [child.id, 1, 2], [child.root_id, child.lft, child.rgt]

  end

  def test_move_a_child_to_another_issue

    parent1 = create_issue!

    parent2 = create_issue!

    child =   create_issue!(:parent_issue_id => parent1.id)

    child.parent_issue_id = parent2.id

    child.save!

    child.reload

    parent1.reload

    parent2.reload

    assert_equal [parent1.id, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]

    assert_equal [parent2.id, 1, 4], [parent2.root_id, parent2.lft, parent2.rgt]

    assert_equal [parent2.id, 2, 3], [child.root_id, child.lft, child.rgt]

  end

  def test_move_a_child_with_descendants_to_another_issue

    parent1 = create_issue!

    parent2 = create_issue!

    child =   create_issue!(:parent_issue_id => parent1.id)

    grandchild = create_issue!(:parent_issue_id => child.id)

    parent1.reload

    parent2.reload

    child.reload

    grandchild.reload

    assert_equal [parent1.id, 1, 6], [parent1.root_id, parent1.lft, parent1.rgt]

    assert_equal [parent2.id, 1, 2], [parent2.root_id, parent2.lft, parent2.rgt]

    assert_equal [parent1.id, 2, 5], [child.root_id, child.lft, child.rgt]

    assert_equal [parent1.id, 3, 4], [grandchild.root_id, grandchild.lft, grandchild.rgt]

    child.reload.parent_issue_id = parent2.id

    child.save!

    child.reload

    grandchild.reload

    parent1.reload

    parent2.reload

    assert_equal [parent1.id, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]

    assert_equal [parent2.id, 1, 6], [parent2.root_id, parent2.lft, parent2.rgt]

    assert_equal [parent2.id, 2, 5], [child.root_id, child.lft, child.rgt]

    assert_equal [parent2.id, 3, 4], [grandchild.root_id, grandchild.lft, grandchild.rgt]

  end

  def test_move_a_child_with_descendants_to_another_project

    parent1 = create_issue!

    child =   create_issue!(:parent_issue_id => parent1.id)

    grandchild = create_issue!(:parent_issue_id => child.id)

    assert child.reload.move_to_project(Project.find(2))

    child.reload

    grandchild.reload

    parent1.reload

    assert_equal [1, parent1.id, 1, 2], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]

    assert_equal [2, child.id, 1, 4], [child.project_id, child.root_id, child.lft, child.rgt]

    assert_equal [2, child.id, 2, 3], [grandchild.project_id, grandchild.root_id, grandchild.lft, grandchild.rgt]

  end

  def test_invalid_move_to_another_project

    parent1 = create_issue!

    child =   create_issue!(:parent_issue_id => parent1.id)

    grandchild = create_issue!(:parent_issue_id => child.id, :tracker_id => 2)

    Project.find(2).tracker_ids = [1]

    parent1.reload

    assert_equal [1, parent1.id, 1, 6], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]

    # child can not be moved to Project 2 because its child is on a disabled tracker

    assert_equal false, Issue.find(child.id).move_to_project(Project.find(2))

    child.reload

    grandchild.reload

    parent1.reload

    # no change

    assert_equal [1, parent1.id, 1, 6], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]

    assert_equal [1, parent1.id, 2, 5], [child.project_id, child.root_id, child.lft, child.rgt]

    assert_equal [1, parent1.id, 3, 4], [grandchild.project_id, grandchild.root_id, grandchild.lft, grandchild.rgt]

  end

  def test_moving_an_issue_to_a_descendant_should_not_validate

    parent1 = create_issue!

    parent2 = create_issue!

    child =   create_issue!(:parent_issue_id => parent1.id)

    grandchild = create_issue!(:parent_issue_id => child.id)

    child.reload

    child.parent_issue_id = grandchild.id

    assert !child.save

    assert_not_nil child.errors.on(:parent_issue_id)

  end

  def test_moving_an_issue_should_keep_valid_relations_only

    issue1 = create_issue!

    issue2 = create_issue!

    assert !IssueRelation.exists?(r2.id)

    assert IssueRelation.exists?(r3.id)

  end

  def test_destroy_should_destroy_children

    issue1 = create_issue!

    issue2 = create_issue!

    issue3 = create_issue!(:parent_issue_id => issue2.id)

    issue4 = create_issue!(:parent_issue_id => issue1.id)

    issue3.init_journal(User.find(2))

    issue3.subject = 'child with journal'

    issue3.save!

    assert_difference 'Issue.count', -2 do

      assert_difference 'Journal.count', -1 do

        assert_difference 'JournalDetail.count', -1 do

        end

      end

    end

    issue1.reload

    issue4.reload

    assert !Issue.exists?(issue2.id)

    assert_equal [issue1.id, 1, 4], [issue1.root_id, issue1.lft, issue1.rgt]

    assert_equal [issue1.id, 2, 3], [issue4.root_id, issue4.lft, issue4.rgt]

  end

  def test_destroy_child_issue_with_children

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

    child = Issue.create!(:project_id => 1, :author_id => 2, :tracker_id => 1, :subject => 'child', :parent_issue_id => root.id)

    leaf.init_journal(User.find(2))

    leaf.subject = 'leaf with journal'

    leaf.save!

    assert_difference 'Issue.count', -2 do

      assert_difference 'Journal.count', -1 do

        assert_difference 'JournalDetail.count', -1 do

        end

      end

    end

    root = Issue.find(root.id)

    assert root.leaf?, "Root issue is not a leaf (lft: #{root.lft}, rgt: #{root.rgt})"

  end

  def test_parent_priority_should_be_the_highest_child_priority

    parent = create_issue!(:priority => IssuePriority.find_by_name('Normal'))

    # Create children

    child3.save!

    assert_equal 'Normal', parent.reload.priority.name

  end

  def test_parent_dates_should_be_lowest_start_and_highest_due_dates

    parent = create_issue!

    create_issue!(:start_date => '2010-01-25', :due_date => '2010-02-15', :parent_issue_id => parent.id)

    assert_equal Date.parse('2010-01-25'), parent.start_date

    assert_equal Date.parse('2010-02-22'), parent.due_date

  end

  def test_parent_done_ratio_should_be_average_done_ratio_of_leaves

    parent = create_issue!

    create_issue!(:done_ratio => 20, :parent_issue_id => parent.id)

    assert_equal 20, parent.reload.done_ratio

    create_issue!(:done_ratio => 70, :parent_issue_id => parent.id)

    assert_equal 45, parent.reload.done_ratio

    child = create_issue!(:done_ratio => 0, :parent_issue_id => parent.id)

    assert_equal 30, parent.reload.done_ratio

    create_issue!(:done_ratio => 30, :parent_issue_id => child.id)

    assert_equal 30, child.reload.done_ratio

    assert_equal 40, parent.reload.done_ratio

  end

  def test_parent_done_ratio_should_be_weighted_by_estimated_times_if_any

    parent = create_issue!

    create_issue!(:estimated_hours => 10, :done_ratio => 20, :parent_issue_id => parent.id)

    create_issue!(:estimated_hours => 20, :done_ratio => 50, :parent_issue_id => parent.id)

    assert_equal (50 * 20 + 20 * 10) / 30, parent.reload.done_ratio

  end

  def test_parent_estimate_should_be_sum_of_leaves

    parent = create_issue!

    create_issue!(:estimated_hours => nil, :parent_issue_id => parent.id)

    parent.reload

    assert_equal [Date.parse('2010-06-02'), Date.parse('2010-06-10')], [parent.start_date, parent.due_date]

  end

  def test_project_copy_should_copy_issue_tree

    p = Project.create!(:name => 'Tree copy', :identifier => 'tree-copy', :tracker_ids => [1, 2])

    i1 = create_issue!(:project_id => p.id, :subject => 'i1')

    c = Project.new(:name => 'Copy', :identifier => 'copy', :tracker_ids => [1, 2])

    c.copy(p, :only => 'issues')

    c.reload

    assert_equal 5, c.issues.count

    ic1, ic2, ic3, ic4, ic5 = c.issues.find(:all, :order => 'subject')

    assert ic1.root?

    assert_equal ic2, ic4.parent

    assert ic5.root?

  end

  # Helper that creates an issue with default attributes

  def create_issue!(attributes={})

    Issue.create!({:project_id => 1, :tracker_id => 1, :author_id => 1, :subject => 'test'}.merge(attributes))

# 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.

           :trackers, :projects_trackers,

           :enabled_modules,

           :versions,

           :enumerations,

           :issues,

           :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,

    issue.reload

    assert_equal 1.5, issue.estimated_hours

  end

  def test_create_minimal

    issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'test_create')

    assert issue.save

    assert issue.description.nil?

  end

  def test_create_with_required_custom_field

    field = IssueCustomField.find_by_name('Database')

    field.update_attribute(:is_required, true)

    issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => 'test_create', :description => 'IssueTest#test_create_with_required_custom_field')

    assert issue.available_custom_fields.include?(field)

    # No value for the custom field

    issue.reload

    assert_equal 'PostgreSQL', issue.custom_value_for(field).value

  end

  def test_visible_scope_for_anonymous

    # Anonymous user should see issues of public projects only

    issues = Issue.visible(User.anonymous).all

    assert issues.any?

    assert_nil issues.detect {|issue| !issue.project.is_public?}

    # Anonymous user should not see issues without permission

    Role.anonymous.remove_permission!(:view_issues)

    issues = Issue.visible(User.anonymous).all

    assert issues.empty?

  end

    user = User.find(9)

    assert user.projects.empty?

    # Non member user should see issues of public projects only

    issues = Issue.visible(user).all

    assert issues.any?

    assert_nil issues.detect {|issue| !issue.project.is_public?}

    # Non member user should not see issues without permission

    Role.non_member.remove_permission!(:view_issues)

    issues = Issue.visible(user).all

    assert issues.empty?

    # User should see issues of projects for which he has view_issues permissions only

    issues = Issue.visible(user).all

    assert issues.any?

  end

  def test_visible_scope_for_admin

    user = User.find(1)

    user.members.each(&:destroy)

    assert issues.any?

    # Admin should see issues on private projects that he does not belong to

    assert issues.detect {|issue| !issue.project.is_public?}

  end

  def test_errors_full_messages_should_include_custom_fields_errors

    field = IssueCustomField.find_by_name('Database')

    issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => 'test_create', :description => 'IssueTest#test_create_with_required_custom_field')

    assert issue.available_custom_fields.include?(field)

    # Invalid value

    issue.custom_field_values = { field.id => 'SQLServer' }

    assert !issue.valid?

    assert_equal 1, issue.errors.full_messages.size

    assert_equal "Database #{I18n.translate('activerecord.errors.messages.inclusion')}", issue.errors.full_messages.first

  end

  def test_update_issue_with_required_custom_field

    field = IssueCustomField.find_by_name('Database')

    field.update_attribute(:is_required, true)

    issue = Issue.find(1)

    assert_nil issue.custom_value_for(field)

    assert issue.available_custom_fields.include?(field)

    issue.reload

    assert_equal 'PostgreSQL', issue.custom_value_for(field).value

  end

  def test_should_not_update_attributes_if_custom_fields_validation_fails

    issue = Issue.find(1)

    field = IssueCustomField.find_by_name('Database')

    assert issue.available_custom_fields.include?(field)

    issue.custom_field_values = { field.id => 'Invalid' }

    issue.subject = 'Should be not be saved'

    assert !issue.save

    issue.reload

    assert_equal "Can't print recipes", issue.subject

  end

  def test_should_not_recreate_custom_values_objects_on_update

    field = IssueCustomField.find_by_name('Database')

    issue = Issue.find(1)

    issue.custom_field_values = { field.id => 'PostgreSQL' }

    assert issue.save

    issue.reload

    assert_equal custom_value.id, issue.custom_value_for(field).id

  end

  def test_assigning_tracker_id_should_reload_custom_fields_values

    issue = Issue.new(:project => Project.find(1))

    assert issue.custom_field_values.empty?

    issue.tracker_id = 1

    assert issue.custom_field_values.any?

  end

  def test_assigning_attributes_should_assign_tracker_id_first

    attributes = ActiveSupport::OrderedHash.new

    attributes['custom_field_values'] = { '1' => 'MySQL' }

    assert_not_nil issue.custom_value_for(1)

    assert_equal 'MySQL', issue.custom_value_for(1).value

  end

  def test_should_update_issue_with_disabled_tracker

    p = Project.find(1)

    issue = Issue.find(1)

    p.trackers.delete(issue.tracker)

    assert !p.trackers.include?(issue.tracker)

    issue.reload

    issue.subject = 'New subject'

    assert issue.save

  end

  def test_should_not_set_a_disabled_tracker

    p = Project.find(1)

    p.trackers.delete(Tracker.find(2))

    issue = Issue.find(1)

    issue.tracker_id = 2

    issue.subject = 'New subject'

    assert !issue.save

    assert_not_nil issue.errors.on(:tracker_id)

  end

  def test_category_based_assignment