jro_apps/redmine Commit - r11085:14b50dfbabc6

Removing shoulda context....

Jean-Philippe Lang -

r11085:14b50dfbabc6

parent child

Context file:

r11085:14b50dfbabc6

Collapse all files

test/unit/attachment_test.rb +32 -34

              # encoding: utf-8
              #
              # Redmine - project management software
              # Copyright (C) 2006-2013  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__)
              class AttachmentTest < ActiveSupport::TestCase
                fixtures :users, :projects, :roles, :members, :member_roles,
                         :enabled_modules, :issues, :trackers, :attachments
                class MockFile
                  attr_reader :original_filename, :content_type, :content, :size
                  def initialize(attributes)
                    @original_filename = attributes[:original_filename]
                    @content_type = attributes[:content_type]
                    @content = attributes[:content] || "Content"
                    @size = content.size
                  end
                end
                def setup
                  set_tmp_attachments_directory
                end
                def test_container_for_new_attachment_should_be_nil
                  assert_nil Attachment.new.container
                end
                def test_create
                  a = Attachment.new(:container => Issue.find(1),
                                     :file => uploaded_test_file("testfile.txt", "text/plain"),
                                     :author => User.find(1))
                  assert a.save
                  assert_equal 'testfile.txt', a.filename
                  assert_equal 59, a.filesize
                  assert_equal 'text/plain', a.content_type
                  assert_equal 0, a.downloads
                  assert_equal '1478adae0d4eb06d35897518540e25d6', a.digest
                  assert a.disk_directory
                  assert_match %r{\A\d{4}/\d{2}\z}, a.disk_directory
                  assert File.exist?(a.diskfile)
                  assert_equal 59, File.size(a.diskfile)
                end
                def test_copy_should_preserve_attributes
                  a = Attachment.find(1)
                  copy = a.copy
                  assert_save copy
                  copy = Attachment.order('id DESC').first
                  %w(filename filesize content_type author_id created_on description digest disk_filename disk_directory diskfile).each do |attribute|
                    assert_equal a.send(attribute), copy.send(attribute), "#{attribute} was different"
                  end
                end
                def test_size_should_be_validated_for_new_file
                  with_settings :attachment_max_size => 0 do
                    a = Attachment.new(:container => Issue.find(1),
                                       :file => uploaded_test_file("testfile.txt", "text/plain"),
                                       :author => User.find(1))
                    assert !a.save
                  end
                end
                def test_size_should_not_be_validated_when_copying
                  a = Attachment.create!(:container => Issue.find(1),
                                         :file => uploaded_test_file("testfile.txt", "text/plain"),
                                         :author => User.find(1))
                  with_settings :attachment_max_size => 0 do
                    copy = a.copy
                    assert copy.save
                  end
                end
                def test_description_length_should_be_validated
                  a = Attachment.new(:description => 'a' * 300)
                  assert !a.save
                  assert_not_nil a.errors[:description]
                end
                def test_destroy
                  a = Attachment.new(:container => Issue.find(1),
                                     :file => uploaded_test_file("testfile.txt", "text/plain"),
                                     :author => User.find(1))
                  assert a.save
                  assert_equal 'testfile.txt', a.filename
                  assert_equal 59, a.filesize
                  assert_equal 'text/plain', a.content_type
                  assert_equal 0, a.downloads
                  assert_equal '1478adae0d4eb06d35897518540e25d6', a.digest
                  diskfile = a.diskfile
                  assert File.exist?(diskfile)
                  assert_equal 59, File.size(a.diskfile)
                  assert a.destroy
                  assert !File.exist?(diskfile)
                end
                def test_destroy_should_not_delete_file_referenced_by_other_attachment
                  a = Attachment.create!(:container => Issue.find(1),
                                         :file => uploaded_test_file("testfile.txt", "text/plain"),
                                         :author => User.find(1))
                  diskfile = a.diskfile
                  copy = a.copy
                  copy.save!
                  assert File.exists?(diskfile)
                  a.destroy
                  assert File.exists?(diskfile)
                  copy.destroy
                  assert !File.exists?(diskfile)
                end
                def test_create_should_auto_assign_content_type
                  a = Attachment.new(:container => Issue.find(1),
                                     :file => uploaded_test_file("testfile.txt", ""),
                                     :author => User.find(1))
                  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))
                  a2 = 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_filename_should_be_basenamed
                  a = Attachment.new(:file => MockFile.new(:original_filename => "path/to/the/file"))
                  assert_equal 'file', a.filename
                end
                def test_filename_should_be_sanitized
                  a = Attachment.new(:file => MockFile.new(:original_filename => "valid:[] invalid:?%*|\"'<>chars"))
                  assert_equal 'valid_[] invalid_chars', a.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]
                  assert_equal '770c509475505f37c2b8fb6030434d6b.txt', Attachment.disk_filename("test_accentué.txt")[13..-1]
                  assert_equal 'f8139524ebb8f32e51976982cd20a85d', Attachment.disk_filename("test_accentué")[13..-1]
                  assert_equal 'cbb5b0f30978ba03731d61f9f6d10011', Attachment.disk_filename("test_accentué.ça")[13..-1]
                end
                def test_title
                  a = Attachment.new(:filename => "test.png")
                  assert_equal "test.png", a.title
                  a = Attachment.new(:filename => "test.png", :description => "Cool image")
                  assert_equal "test.png (Cool image)", a.title
                end
                def test_prune_should_destroy_old_unattached_attachments
                  Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1, :created_on => 2.days.ago)
                  Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1, :created_on => 2.days.ago)
                  Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1)
                  assert_difference 'Attachment.count', -2 do
                    Attachment.prune
                  end
                end
                def test_move_from_root_to_target_directory_should_move_root_files
                  a = Attachment.find(20)
                  assert a.disk_directory.blank?
                  # Create a real file for this fixture
                  File.open(a.diskfile, "w") do |f|
                    f.write "test file at the root of files directory"
                  end
                  assert a.readable?
                  Attachment.move_from_root_to_target_directory
                  a.reload
                  assert_equal '2012/05', a.disk_directory
                  assert a.readable?
                end
-               context "Attachmnet.attach_files" do
-                 should "attach the file" do
-                   issue = Issue.first
-                   assert_difference 'Attachment.count' do
-                     Attachment.attach_files(issue,
-                       '1' => {
-                         'file' => uploaded_test_file('testfile.txt', 'text/plain'),
-                         'description' => 'test'
-                       })
-                   end
-                   attachment = Attachment.first(:order => 'id DESC')
-                   assert_equal issue, attachment.container
-                   assert_equal 'testfile.txt', attachment.filename
-                   assert_equal 59, attachment.filesize
-                   assert_equal 'test', attachment.description
-                   assert_equal 'text/plain', attachment.content_type
-                   assert File.exists?(attachment.diskfile)
-                   assert_equal 59, File.size(attachment.diskfile)
+               test "Attachmnet.attach_files should attach the file" do
+                 issue = Issue.first
+                 assert_difference 'Attachment.count' do
+                   Attachment.attach_files(issue,
+                     '1' => {
+                       'file' => uploaded_test_file('testfile.txt', 'text/plain'),
+                       'description' => 'test'
+                     })
                  end
-                 should "add unsaved files to the object as unsaved attachments" do
-                   # Max size of 0 to force Attachment creation failures
-                   with_settings(:attachment_max_size => 0) do
-                     @project = Project.find(1)
-                     response = Attachment.attach_files(@project, {
-                                                          '1' => {'file' => mock_file, 'description' => 'test'},
-                                                          '2' => {'file' => mock_file, 'description' => 'test'}
-                                                        })
-                     assert response[:unsaved].present?
-                     assert_equal 2, response[:unsaved].length
-                     assert response[:unsaved].first.new_record?
-                     assert response[:unsaved].second.new_record?
-                     assert_equal response[:unsaved], @project.unsaved_attachments
-                   end
+                 attachment = Attachment.first(:order => 'id DESC')
+                 assert_equal issue, attachment.container
+                 assert_equal 'testfile.txt', attachment.filename
+                 assert_equal 59, attachment.filesize
+                 assert_equal 'test', attachment.description
+                 assert_equal 'text/plain', attachment.content_type
+                 assert File.exists?(attachment.diskfile)
+                 assert_equal 59, File.size(attachment.diskfile)
+               end
+               test "Attachmnet.attach_files should add unsaved files to the object as unsaved attachments" do
+                 # Max size of 0 to force Attachment creation failures
+                 with_settings(:attachment_max_size => 0) do
+                   @project = Project.find(1)
+                   response = Attachment.attach_files(@project, {
+                                                        '1' => {'file' => mock_file, 'description' => 'test'},
+                                                        '2' => {'file' => mock_file, 'description' => 'test'}
+                                                      })
+                   assert response[:unsaved].present?
+                   assert_equal 2, response[:unsaved].length
+                   assert response[:unsaved].first.new_record?
+                   assert response[:unsaved].second.new_record?
+                   assert_equal response[:unsaved], @project.unsaved_attachments
                  end
                end
                def test_latest_attach
                  set_fixtures_attachments_directory
                  a1 = Attachment.find(16)
                  assert_equal "testfile.png", a1.filename
                  assert a1.readable?
                  assert (! a1.visible?(User.anonymous))
                  assert a1.visible?(User.find(2))
                  a2 = Attachment.find(17)
                  assert_equal "testfile.PNG", a2.filename
                  assert a2.readable?
                  assert (! a2.visible?(User.anonymous))
                  assert a2.visible?(User.find(2))
                  assert a1.created_on < a2.created_on
                  la1 = Attachment.latest_attach([a1, a2], "testfile.png")
                  assert_equal 17, la1.id
                  la2 = Attachment.latest_attach([a1, a2], "Testfile.PNG")
                  assert_equal 17, la2.id
                  set_tmp_attachments_directory
                end
                def test_thumbnailable_should_be_true_for_images
                  assert_equal true, Attachment.new(:filename => 'test.jpg').thumbnailable?
                end
                def test_thumbnailable_should_be_true_for_non_images
                  assert_equal false, Attachment.new(:filename => 'test.txt').thumbnailable?
                end
                if convert_installed?
                  def test_thumbnail_should_generate_the_thumbnail
                    set_fixtures_attachments_directory
                    attachment = Attachment.find(16)
                    Attachment.clear_thumbnails
                    assert_difference "Dir.glob(File.join(Attachment.thumbnails_storage_path, '*.thumb')).size" do
                      thumbnail = attachment.thumbnail
                      assert_equal "16_8e0294de2441577c529f170b6fb8f638_100.thumb", File.basename(thumbnail)
                      assert File.exists?(thumbnail)
                    end
                  end
                else
                  puts '(ImageMagick convert not available)'
                end
              end

test/unit/auth_source_ldap_test.rb +35 -48

              # Redmine - project management software
              # Copyright (C) 2006-2013  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__)
              class AuthSourceLdapTest < ActiveSupport::TestCase
                include Redmine::I18n
                fixtures :auth_sources
                def setup
                end
                def test_create
                  a = AuthSourceLdap.new(:name => 'My LDAP', :host => 'ldap.example.net', :port => 389, :base_dn => 'dc=example,dc=net', :attr_login => 'sAMAccountName')
                  assert a.save
                end
                def test_should_strip_ldap_attributes
                  a = AuthSourceLdap.new(:name => 'My LDAP', :host => 'ldap.example.net', :port => 389, :base_dn => 'dc=example,dc=net', :attr_login => 'sAMAccountName',
                                         :attr_firstname => 'givenName ')
                  assert a.save
                  assert_equal 'givenName', a.reload.attr_firstname
                end
                def test_replace_port_zero_to_389
                  a = AuthSourceLdap.new(
                         :name => 'My LDAP', :host => 'ldap.example.net', :port => 0,
                         :base_dn => 'dc=example,dc=net', :attr_login => 'sAMAccountName',
                         :attr_firstname => 'givenName ')
                  assert a.save
                  assert_equal 389, a.port
                end
                def test_filter_should_be_validated
                  set_language_if_valid 'en'
                  a = AuthSourceLdap.new(:name => 'My LDAP', :host => 'ldap.example.net', :port => 389, :attr_login => 'sn')
                  a.filter = "(mail=*@redmine.org"
                  assert !a.valid?
                  assert_include "LDAP filter is invalid", a.errors.full_messages
                  a.filter = "(mail=*@redmine.org)"
                  assert a.valid?
                end
                if ldap_configured?
-                 context '#authenticate' do
-                   setup do
-                     @auth = AuthSourceLdap.find(1)
-                     @auth.update_attribute :onthefly_register, true
-                   end
-                   context 'with a valid LDAP user' do
-                     should 'return the user attributes' do
-                       attributes =  @auth.authenticate('example1','123456')
-                       assert attributes.is_a?(Hash), "An hash was not returned"
-                       assert_equal 'Example', attributes[:firstname]
-                       assert_equal 'One', attributes[:lastname]
-                       assert_equal 'example1@redmine.org', attributes[:mail]
-                       assert_equal @auth.id, attributes[:auth_source_id]
-                       attributes.keys.each do |attribute|
-                         assert User.new.respond_to?("#{attribute}="), "Unexpected :#{attribute} attribute returned"
-                       end
-                     end
+                 test '#authenticate with a valid LDAP user should return the user attributes' do
+                   auth = AuthSourceLdap.find(1)
+                   auth.update_attribute :onthefly_register, true
+                   attributes =  auth.authenticate('example1','123456')
+                   assert attributes.is_a?(Hash), "An hash was not returned"
+                   assert_equal 'Example', attributes[:firstname]
+                   assert_equal 'One', attributes[:lastname]
+                   assert_equal 'example1@redmine.org', attributes[:mail]
+                   assert_equal auth.id, attributes[:auth_source_id]
+                   attributes.keys.each do |attribute|
+                     assert User.new.respond_to?("#{attribute}="), "Unexpected :#{attribute} attribute returned"
                    end
+                 end
-                   context 'with an invalid LDAP user' do
-                     should 'return nil' do
-                       assert_equal nil, @auth.authenticate('nouser','123456')
-                     end
-                   end
+                 test '#authenticate with an invalid LDAP user should return nil' do
+                   auth = AuthSourceLdap.find(1)
+                   assert_equal nil, auth.authenticate('nouser','123456')
+                 end
-                   context 'without a login' do
-                     should 'return nil' do
-                       assert_equal nil, @auth.authenticate('','123456')
-                     end
-                   end
+                 test '#authenticate without a login should return nil' do
+                   auth = AuthSourceLdap.find(1)
+                   assert_equal nil, auth.authenticate('','123456')
+                 end
-                   context 'without a password' do
-                     should 'return nil' do
-                       assert_equal nil, @auth.authenticate('edavis','')
-                     end
-                   end
+                 test '#authenticate without a password should return nil' do
+                   auth = AuthSourceLdap.find(1)
+                   assert_equal nil, auth.authenticate('edavis','')
+                 end
-                   context 'without filter' do
-                     should 'return any user' do
-                       assert @auth.authenticate('example1','123456')
-                       assert @auth.authenticate('edavis', '123456')
-                     end
-                   end
+                 test '#authenticate without filter should return any user' do
+                   auth = AuthSourceLdap.find(1)
+                   assert auth.authenticate('example1','123456')
+                   assert auth.authenticate('edavis', '123456')
+                 end
-                   context 'with filter' do
-                     setup do
-                       @auth.filter = "(mail=*@redmine.org)"
-                     end
+                 test '#authenticate with filter should return user who matches the filter only' do
+                   auth = AuthSourceLdap.find(1)
+                   auth.filter = "(mail=*@redmine.org)"
-                     should 'return user who matches the filter only' do
-                       assert @auth.authenticate('example1','123456')
-                       assert_nil @auth.authenticate('edavis', '123456')
-                     end
-                   end
+                   assert auth.authenticate('example1','123456')
+                   assert_nil auth.authenticate('edavis', '123456')
                  end
                  def test_authenticate_should_timeout
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.timeout = 1
                    def auth_source.initialize_ldap_con(*args); sleep(5); end
                    assert_raise AuthSourceTimeoutException do
                      auth_source.authenticate 'example1', '123456'
                    end
                  end
                  def test_search_should_return_matching_entries
                    results = AuthSource.search("exa")
                    assert_equal 1, results.size
                    result = results.first
                    assert_kind_of Hash, result
                    assert_equal "example1", result[:login]
                    assert_equal "Example", result[:firstname]
                    assert_equal "One", result[:lastname]
                    assert_equal "example1@redmine.org", result[:mail]
                    assert_equal 1, result[:auth_source_id]
                  end
                  def test_search_with_no_match_should_return_an_empty_array
                    results = AuthSource.search("wro")
                    assert_equal [], results
                  end
                  def test_search_with_exception_should_return_an_empty_array
                    Net::LDAP.stubs(:new).raises(Net::LDAP::LdapError, 'Cannot connect')
                    results = AuthSource.search("exa")
                    assert_equal [], results
                  end
                else
                  puts '(Test LDAP server not configured)'
                end
              end

test/unit/issue_test.rb +154 -206

              # Redmine - project management software
              # Copyright (C) 2006-2013  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__)
              class IssueTest < ActiveSupport::TestCase
                fixtures :projects, :users, :members, :member_roles, :roles,
                         :groups_users,
                         :trackers, :projects_trackers,
                         :enabled_modules,
                         :versions,
                         :issue_statuses, :issue_categories, :issue_relations, :workflows,
                         :enumerations,
                         :issues, :journals, :journal_details,
                         :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,
                         :time_entries
                include Redmine::I18n
                def teardown
                  User.current = nil
                end
                def test_create
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                    :status_id => 1, :priority => IssuePriority.all.first,
                                    :subject => 'test_create',
                                    :description => 'IssueTest#test_create', :estimated_hours => '1:30')
                  assert issue.save
                  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?
                  assert_nil issue.estimated_hours
                end
                def test_start_date_format_should_be_validated
                  set_language_if_valid 'en'
                  ['2012', 'ABC', '2012-15-20'].each do |invalid_date|
                    issue = Issue.new(:start_date => invalid_date)
                    assert !issue.valid?
                    assert_include 'Start date is not a valid date', issue.errors.full_messages, "No error found for invalid date #{invalid_date}"
                  end
                end
                def test_due_date_format_should_be_validated
                  set_language_if_valid 'en'
                  ['2012', 'ABC', '2012-15-20'].each do |invalid_date|
                    issue = Issue.new(:due_date => invalid_date)
                    assert !issue.valid?
                    assert_include 'Due date is not a valid date', issue.errors.full_messages, "No error found for invalid date #{invalid_date}"
                  end
                end
                def test_due_date_lesser_than_start_date_should_not_validate
                  set_language_if_valid 'en'
                  issue = Issue.new(:start_date => '2012-10-06', :due_date => '2012-10-02')
                  assert !issue.valid?
                  assert_include 'Due date must be greater than start date', issue.errors.full_messages
                end
                def test_estimated_hours_should_be_validated
                  set_language_if_valid 'en'
                  ['-2'].each do |invalid|
                    issue = Issue.new(:estimated_hours => invalid)
                    assert !issue.valid?
                    assert_include 'Estimated time is invalid', issue.errors.full_messages
                  end
                end
                def test_create_with_required_custom_field
                  set_language_if_valid 'en'
                  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
                  assert !issue.save
                  assert_equal ["Database can't be blank"], issue.errors.full_messages
                  # Blank value
                  issue.custom_field_values = { field.id => '' }
                  assert !issue.save
                  assert_equal ["Database can't be blank"], issue.errors.full_messages
                  # Invalid value
                  issue.custom_field_values = { field.id => 'SQLServer' }
                  assert !issue.save
                  assert_equal ["Database is not included in the list"], issue.errors.full_messages
                  # Valid value
                  issue.custom_field_values = { field.id => 'PostgreSQL' }
                  assert issue.save
                  issue.reload
                  assert_equal 'PostgreSQL', issue.custom_value_for(field).value
                end
                def test_create_with_group_assignment
                  with_settings :issue_group_assignment => '1' do
                    assert Issue.new(:project_id => 2, :tracker_id => 1, :author_id => 1,
                                     :subject => 'Group assignment',
                                     :assigned_to_id => 11).save
                    issue = Issue.first(:order => 'id DESC')
                    assert_kind_of Group, issue.assigned_to
                    assert_equal Group.find(11), issue.assigned_to
                  end
                end
                def test_create_with_parent_issue_id
                  issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                    :author_id => 1, :subject => 'Group assignment',
                                    :parent_issue_id => 1)
                  assert_save issue
                  assert_equal 1, issue.parent_issue_id
                  assert_equal Issue.find(1), issue.parent
                end
                def test_create_with_sharp_parent_issue_id
                  issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                    :author_id => 1, :subject => 'Group assignment',
                                    :parent_issue_id => "#1")
                  assert_save issue
                  assert_equal 1, issue.parent_issue_id
                  assert_equal Issue.find(1), issue.parent
                end
                def test_create_with_invalid_parent_issue_id
                  set_language_if_valid 'en'
                  issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                    :author_id => 1, :subject => 'Group assignment',
                                    :parent_issue_id => '01ABC')
                  assert !issue.save
                  assert_equal '01ABC', issue.parent_issue_id
                  assert_include 'Parent task is invalid', issue.errors.full_messages
                end
                def test_create_with_invalid_sharp_parent_issue_id
                  set_language_if_valid 'en'
                  issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                    :author_id => 1, :subject => 'Group assignment',
                                    :parent_issue_id => '#01ABC')
                  assert !issue.save
                  assert_equal '#01ABC', issue.parent_issue_id
                  assert_include 'Parent task is invalid', issue.errors.full_messages
                end
                def assert_visibility_match(user, issues)
                  assert_equal issues.collect(&:id).sort, Issue.all.select {|issue| issue.visible?(user)}.collect(&:id).sort
                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?}
                  assert_nil issues.detect {|issue| issue.is_private?}
                  assert_visibility_match User.anonymous, issues
                end
                def test_visible_scope_for_anonymous_without_view_issues_permissions
                  # Anonymous user should not see issues without permission
                  Role.anonymous.remove_permission!(:view_issues)
                  issues = Issue.visible(User.anonymous).all
                  assert issues.empty?
                  assert_visibility_match User.anonymous, issues
                end
                def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_default
                  assert Role.anonymous.update_attribute(:issues_visibility, 'default')
                  issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)
                  assert_nil Issue.where(:id => issue.id).visible(User.anonymous).first
                  assert !issue.visible?(User.anonymous)
                end
                def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_own
                  assert Role.anonymous.update_attribute(:issues_visibility, 'own')
                  issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)
                  assert_nil Issue.where(:id => issue.id).visible(User.anonymous).first
                  assert !issue.visible?(User.anonymous)
                end
                def test_visible_scope_for_non_member
                  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?}
                  assert_nil issues.detect {|issue| issue.is_private?}
                  assert_visibility_match user, issues
                end
                def test_visible_scope_for_non_member_with_own_issues_visibility
                  Role.non_member.update_attribute :issues_visibility, 'own'
                  Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 9, :subject => 'Issue by non member')
                  user = User.find(9)
                  issues = Issue.visible(user).all
                  assert issues.any?
                  assert_nil issues.detect {|issue| issue.author != user}
                  assert_visibility_match user, issues
                end
                def test_visible_scope_for_non_member_without_view_issues_permissions
                  # Non member user should not see issues without permission
                  Role.non_member.remove_permission!(:view_issues)
                  user = User.find(9)
                  assert user.projects.empty?
                  issues = Issue.visible(user).all
                  assert issues.empty?
                  assert_visibility_match user, issues
                end
                def test_visible_scope_for_member
                  user = User.find(9)
                  # User should see issues of projects for which he has view_issues permissions only
                  Role.non_member.remove_permission!(:view_issues)
                  Member.create!(:principal => user, :project_id => 3, :role_ids => [2])
                  issues = Issue.visible(user).all
                  assert issues.any?
                  assert_nil issues.detect {|issue| issue.project_id != 3}
                  assert_nil issues.detect {|issue| issue.is_private?}
                  assert_visibility_match user, issues
                end
                def test_visible_scope_for_member_with_groups_should_return_assigned_issues
                  user = User.find(8)
                  assert user.groups.any?
                  Member.create!(:principal => user.groups.first, :project_id => 1, :role_ids => [2])
                  Role.non_member.remove_permission!(:view_issues)
                  issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,
                    :status_id => 1, :priority => IssuePriority.all.first,
                    :subject => 'Assignment test',
                    :assigned_to => user.groups.first,
                    :is_private => true)
                  Role.find(2).update_attribute :issues_visibility, 'default'
                  issues = Issue.visible(User.find(8)).all
                  assert issues.any?
                  assert issues.include?(issue)
                  Role.find(2).update_attribute :issues_visibility, 'own'
                  issues = Issue.visible(User.find(8)).all
                  assert issues.any?
                  assert issues.include?(issue)
                end
                def test_visible_scope_for_admin
                  user = User.find(1)
                  user.members.each(&:destroy)
                  assert user.projects.empty?
                  issues = Issue.visible(user).all
                  assert issues.any?
                  # Admin should see issues on private projects that he does not belong to
                  assert issues.detect {|issue| !issue.project.is_public?}
                  # Admin should see private issues of other users
                  assert issues.detect {|issue| issue.is_private? && issue.author != user}
                  assert_visibility_match user, issues
                end
                def test_visible_scope_with_project
                  project = Project.find(1)
                  issues = Issue.visible(User.find(2), :project => project).all
                  projects = issues.collect(&:project).uniq
                  assert_equal 1, projects.size
                  assert_equal project, projects.first
                end
                def test_visible_scope_with_project_and_subprojects
                  project = Project.find(1)
                  issues = Issue.visible(User.find(2), :project => project, :with_subprojects => true).all
                  projects = issues.collect(&:project).uniq
                  assert projects.size > 1
                  assert_equal [], projects.select {|p| !p.is_or_is_descendant_of?(project)}
                end
                def test_visible_and_nested_set_scopes
                  assert_equal 0, Issue.find(1).descendants.visible.all.size
                end
                def test_open_scope
                  issues = Issue.open.all
                  assert_nil issues.detect(&:closed?)
                end
                def test_open_scope_with_arg
                  issues = Issue.open(false).all
                  assert_equal issues, issues.select(&:closed?)
                end
                def test_fixed_version_scope_with_a_version_should_return_its_fixed_issues
                  version = Version.find(2)
                  assert version.fixed_issues.any?
                  assert_equal version.fixed_issues.to_a.sort, Issue.fixed_version(version).to_a.sort
                end
                def test_fixed_version_scope_with_empty_array_should_return_no_result
                  assert_equal 0, Issue.fixed_version([]).count
                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)
                  # No change to custom values, issue can be saved
                  assert issue.save
                  # Blank value
                  issue.custom_field_values = { field.id => '' }
                  assert !issue.save
                  # Valid value
                  issue.custom_field_values = { field.id => 'PostgreSQL' }
                  assert issue.save
                  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
                  custom_value = issue.custom_value_for(field)
                  issue.reload
                  issue.custom_field_values = { field.id => 'MySQL' }
                  assert issue.save
                  issue.reload
                  assert_equal custom_value.id, issue.custom_value_for(field).id
                end
                def test_should_not_update_custom_fields_on_changing_tracker_with_different_custom_fields
                  issue = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                        :status_id => 1, :subject => 'Test',
                                        :custom_field_values => {'2' => 'Test'})
                  assert !Tracker.find(2).custom_field_ids.include?(2)
                  issue = Issue.find(issue.id)
                  issue.attributes = {:tracker_id => 2, :custom_field_values => {'1' => ''}}
                  issue = Issue.find(issue.id)
                  custom_value = issue.custom_value_for(2)
                  assert_not_nil custom_value
                  assert_equal 'Test', custom_value.value
                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_project_and_tracker_first
                  seq = sequence('seq')
                  issue = Issue.new
                  issue.expects(:project_id=).in_sequence(seq)
                  issue.expects(:tracker_id=).in_sequence(seq)
                  issue.expects(:subject=).in_sequence(seq)
                  issue.attributes = {:tracker_id => 2, :project_id => 1, :subject => 'Test'}
                end
                def test_assigning_tracker_and_custom_fields_should_assign_custom_fields
                  attributes = ActiveSupport::OrderedHash.new
                  attributes['custom_field_values'] = { '1' => 'MySQL' }
                  attributes['tracker_id'] = '1'
                  issue = Issue.new(:project => Project.find(1))
                  issue.attributes = attributes
                  assert_equal 'MySQL', issue.custom_field_value(1)
                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[:tracker_id]
                end
                def test_category_based_assignment
                  issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                       :status_id => 1, :priority => IssuePriority.all.first,
                                       :subject => 'Assignment test',
                                       :description => 'Assignment test', :category_id => 1)
                  assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to
                end
                def test_new_statuses_allowed_to
                  WorkflowTransition.delete_all
                  WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                                             :old_status_id => 1, :new_status_id => 2,
                                             :author => false, :assignee => false)
                  WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                                             :old_status_id => 1, :new_status_id => 3,
                                             :author => true, :assignee => false)
                  WorkflowTransition.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1,
                                             :new_status_id => 4, :author => false,
                                             :assignee => true)
                  WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                                             :old_status_id => 1, :new_status_id => 5,
                                             :author => true, :assignee => true)
                  status = IssueStatus.find(1)
                  role = Role.find(1)
                  tracker = Tracker.find(1)
                  user = User.find(2)
                  issue = Issue.generate!(:tracker => tracker, :status => status,
                                          :project_id => 1, :author_id => 1)
                  assert_equal [1, 2], issue.new_statuses_allowed_to(user).map(&:id)
                  issue = Issue.generate!(:tracker => tracker, :status => status,
                                          :project_id => 1, :author => user)
                  assert_equal [1, 2, 3, 5], issue.new_statuses_allowed_to(user).map(&:id)
                  issue = Issue.generate!(:tracker => tracker, :status => status,
                                          :project_id => 1, :author_id => 1,
                                          :assigned_to => user)
                  assert_equal [1, 2, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
                  issue = Issue.generate!(:tracker => tracker, :status => status,
                                          :project_id => 1, :author => user,
                                          :assigned_to => user)
                  assert_equal [1, 2, 3, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
                end
                def test_new_statuses_allowed_to_should_return_all_transitions_for_admin
                  admin = User.find(1)
                  issue = Issue.find(1)
                  assert !admin.member_of?(issue.project)
                  expected_statuses = [issue.status] +
                                          WorkflowTransition.find_all_by_old_status_id(
                                              issue.status_id).map(&:new_status).uniq.sort
                  assert_equal expected_statuses, issue.new_statuses_allowed_to(admin)
                end
                def test_new_statuses_allowed_to_should_return_default_and_current_status_when_copying
                  issue = Issue.find(1).copy
                  assert_equal [1], issue.new_statuses_allowed_to(User.find(2)).map(&:id)
                  issue = Issue.find(2).copy
                  assert_equal [1, 2], issue.new_statuses_allowed_to(User.find(2)).map(&:id)
                end
                def test_safe_attributes_names_should_not_include_disabled_field
                  tracker = Tracker.new(:core_fields => %w(assigned_to_id fixed_version_id))
                  issue = Issue.new(:tracker => tracker)
                  assert_include 'tracker_id', issue.safe_attribute_names
                  assert_include 'status_id', issue.safe_attribute_names
                  assert_include 'subject', issue.safe_attribute_names
                  assert_include 'description', issue.safe_attribute_names
                  assert_include 'custom_field_values', issue.safe_attribute_names
                  assert_include 'custom_fields', issue.safe_attribute_names
                  assert_include 'lock_version', issue.safe_attribute_names
                  tracker.core_fields.each do |field|
                    assert_include field, issue.safe_attribute_names
                  end
                  tracker.disabled_core_fields.each do |field|
                    assert_not_include field, issue.safe_attribute_names
                  end
                end
                def test_safe_attributes_should_ignore_disabled_fields
                  tracker = Tracker.find(1)
                  tracker.core_fields = %w(assigned_to_id due_date)
                  tracker.save!
                  issue = Issue.new(:tracker => tracker)
                  issue.safe_attributes = {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}
                  assert_nil issue.start_date
                  assert_equal Date.parse('2012-07-14'), issue.due_date
                end
                def test_safe_attributes_should_accept_target_tracker_enabled_fields
                  source = Tracker.find(1)
                  source.core_fields = []
                  source.save!
                  target = Tracker.find(2)
                  target.core_fields = %w(assigned_to_id due_date)
                  target.save!
                  issue = Issue.new(:tracker => source)
                  issue.safe_attributes = {'tracker_id' => 2, 'due_date' => '2012-07-14'}
                  assert_equal target, issue.tracker
                  assert_equal Date.parse('2012-07-14'), issue.due_date
                end
                def test_safe_attributes_should_not_include_readonly_fields
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => 'due_date',
                                             :rule => 'readonly')
                  user = User.find(2)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1)
                  assert_equal %w(due_date), issue.read_only_attribute_names(user)
                  assert_not_include 'due_date', issue.safe_attribute_names(user)
                  issue.send :safe_attributes=, {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}, user
                  assert_equal Date.parse('2012-07-14'), issue.start_date
                  assert_nil issue.due_date
                end
                def test_safe_attributes_should_not_include_readonly_custom_fields
                  cf1 = IssueCustomField.create!(:name => 'Writable field',
                                                 :field_format => 'string',
                                                 :is_for_all => true, :tracker_ids => [1])
                  cf2 = IssueCustomField.create!(:name => 'Readonly field',
                                                 :field_format => 'string',
                                                 :is_for_all => true, :tracker_ids => [1])
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => cf2.id.to_s,
                                             :rule => 'readonly')
                  user = User.find(2)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1)
                  assert_equal [cf2.id.to_s], issue.read_only_attribute_names(user)
                  assert_not_include cf2.id.to_s, issue.safe_attribute_names(user)
                  issue.send :safe_attributes=, {'custom_field_values' => {
                                                     cf1.id.to_s => 'value1', cf2.id.to_s => 'value2'
                                                   }}, user
                  assert_equal 'value1', issue.custom_field_value(cf1)
                  assert_nil issue.custom_field_value(cf2)
                  issue.send :safe_attributes=, {'custom_fields' => [
                                                    {'id' => cf1.id.to_s, 'value' => 'valuea'},
                                                    {'id' => cf2.id.to_s, 'value' => 'valueb'}
                                                  ]}, user
                  assert_equal 'valuea', issue.custom_field_value(cf1)
                  assert_nil issue.custom_field_value(cf2)
                end
                def test_editable_custom_field_values_should_return_non_readonly_custom_values
                  cf1 = IssueCustomField.create!(:name => 'Writable field', :field_format => 'string',
                                                 :is_for_all => true, :tracker_ids => [1, 2])
                  cf2 = IssueCustomField.create!(:name => 'Readonly field', :field_format => 'string',
                                                 :is_for_all => true, :tracker_ids => [1, 2])
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1,
                                             :field_name => cf2.id.to_s, :rule => 'readonly')
                  user = User.find(2)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1)
                  values = issue.editable_custom_field_values(user)
                  assert values.detect {|value| value.custom_field == cf1}
                  assert_nil values.detect {|value| value.custom_field == cf2}
                  issue.tracker_id = 2
                  values = issue.editable_custom_field_values(user)
                  assert values.detect {|value| value.custom_field == cf1}
                  assert values.detect {|value| value.custom_field == cf2}
                end
                def test_safe_attributes_should_accept_target_tracker_writable_fields
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => 'due_date',
                                             :rule => 'readonly')
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,
                                             :role_id => 1, :field_name => 'start_date',
                                             :rule => 'readonly')
                  user = User.find(2)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                  issue.send :safe_attributes=, {'start_date' => '2012-07-12',
                                                 'due_date' => '2012-07-14'}, user
                  assert_equal Date.parse('2012-07-12'), issue.start_date
                  assert_nil issue.due_date
                  issue.send :safe_attributes=, {'start_date' => '2012-07-15',
                                                 'due_date' => '2012-07-16',
                                                 'tracker_id' => 2}, user
                  assert_equal Date.parse('2012-07-12'), issue.start_date
                  assert_equal Date.parse('2012-07-16'), issue.due_date
                end
                def test_safe_attributes_should_accept_target_status_writable_fields
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => 'due_date',
                                             :rule => 'readonly')
                  WorkflowPermission.create!(:old_status_id => 2, :tracker_id => 1,
                                             :role_id => 1, :field_name => 'start_date',
                                             :rule => 'readonly')
                  user = User.find(2)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                  issue.send :safe_attributes=, {'start_date' => '2012-07-12',
                                                 'due_date' => '2012-07-14'},
                                                 user
                  assert_equal Date.parse('2012-07-12'), issue.start_date
                  assert_nil issue.due_date
                  issue.send :safe_attributes=, {'start_date' => '2012-07-15',
                                                  'due_date' => '2012-07-16',
                                                  'status_id' => 2},
                                                user
                  assert_equal Date.parse('2012-07-12'), issue.start_date
                  assert_equal Date.parse('2012-07-16'), issue.due_date
                end
                def test_required_attributes_should_be_validated
                  cf = IssueCustomField.create!(:name => 'Foo', :field_format => 'string',
                                                :is_for_all => true, :tracker_ids => [1, 2])
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => 'due_date',
                                             :rule => 'required')
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => 'category_id',
                                             :rule => 'required')
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => cf.id.to_s,
                                             :rule => 'required')
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,
                                             :role_id => 1, :field_name => 'start_date',
                                             :rule => 'required')
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,
                                             :role_id => 1, :field_name => cf.id.to_s,
                                             :rule => 'required')
                  user = User.find(2)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                    :status_id => 1, :subject => 'Required fields',
                                    :author => user)
                  assert_equal [cf.id.to_s, "category_id", "due_date"],
                               issue.required_attribute_names(user).sort
                  assert !issue.save, "Issue was saved"
                  assert_equal ["Category can't be blank", "Due date can't be blank", "Foo can't be blank"],
                                issue.errors.full_messages.sort
                  issue.tracker_id = 2
                  assert_equal [cf.id.to_s, "start_date"], issue.required_attribute_names(user).sort
                  assert !issue.save, "Issue was saved"
                  assert_equal ["Foo can't be blank", "Start date can't be blank"],
                               issue.errors.full_messages.sort
                  issue.start_date = Date.today
                  issue.custom_field_values = {cf.id.to_s => 'bar'}
                  assert issue.save
                end
                def test_required_attribute_names_for_multiple_roles_should_intersect_rules
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => 'due_date',
                                             :rule => 'required')
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => 'start_date',
                                             :rule => 'required')
                  user = User.find(2)
                  member = Member.find(1)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                  assert_equal %w(due_date start_date), issue.required_attribute_names(user).sort
                  member.role_ids = [1, 2]
                  member.save!
                  assert_equal [], issue.required_attribute_names(user.reload)
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 2, :field_name => 'due_date',
                                             :rule => 'required')
                  assert_equal %w(due_date), issue.required_attribute_names(user)
                  member.role_ids = [1, 2, 3]
                  member.save!
                  assert_equal [], issue.required_attribute_names(user.reload)
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 2, :field_name => 'due_date',
                                             :rule => 'readonly')
                  # required + readonly => required
                  assert_equal %w(due_date), issue.required_attribute_names(user)
                end
                def test_read_only_attribute_names_for_multiple_roles_should_intersect_rules
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => 'due_date',
                                             :rule => 'readonly')
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => 'start_date',
                                             :rule => 'readonly')
                  user = User.find(2)
                  member = Member.find(1)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                  assert_equal %w(due_date start_date), issue.read_only_attribute_names(user).sort
                  member.role_ids = [1, 2]
                  member.save!
                  assert_equal [], issue.read_only_attribute_names(user.reload)
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 2, :field_name => 'due_date',
                                            :rule => 'readonly')
                  assert_equal %w(due_date), issue.read_only_attribute_names(user)
                end
                def test_copy
                  issue = Issue.new.copy_from(1)
                  assert issue.copy?
                  assert issue.save
                  issue.reload
                  orig = Issue.find(1)
                  assert_equal orig.subject, issue.subject
                  assert_equal orig.tracker, issue.tracker
                  assert_equal "125", issue.custom_value_for(2).value
                end
                def test_copy_should_copy_status
                  orig = Issue.find(8)
                  assert orig.status != IssueStatus.default
                  issue = Issue.new.copy_from(orig)
                  assert issue.save
                  issue.reload
                  assert_equal orig.status, issue.status
                end
                def test_copy_should_add_relation_with_copied_issue
                  copied = Issue.find(1)
                  issue = Issue.new.copy_from(copied)
                  assert issue.save
                  issue.reload
                  assert_equal 1, issue.relations.size
                  relation = issue.relations.first
                  assert_equal 'copied_to', relation.relation_type
                  assert_equal copied, relation.issue_from
                  assert_equal issue, relation.issue_to
                end
                def test_copy_should_copy_subtasks
                  issue = Issue.generate_with_descendants!
                  copy = issue.reload.copy
                  copy.author = User.find(7)
                  assert_difference 'Issue.count', 1+issue.descendants.count do
                    assert copy.save
                  end
                  copy.reload
                  assert_equal %w(Child1 Child2), copy.children.map(&:subject).sort
                  child_copy = copy.children.detect {|c| c.subject == 'Child1'}
                  assert_equal %w(Child11), child_copy.children.map(&:subject).sort
                  assert_equal copy.author, child_copy.author
                end
                def test_copy_should_copy_subtasks_to_target_project
                  issue = Issue.generate_with_descendants!
                  copy = issue.copy(:project_id => 3)
                  assert_difference 'Issue.count', 1+issue.descendants.count do
                    assert copy.save
                  end
                  assert_equal [3], copy.reload.descendants.map(&:project_id).uniq
                end
                def test_copy_should_not_copy_subtasks_twice_when_saving_twice
                  issue = Issue.generate_with_descendants!
                  copy = issue.reload.copy
                  assert_difference 'Issue.count', 1+issue.descendants.count do
                    assert copy.save
                    assert copy.save
                  end
                end
                def test_should_not_call_after_project_change_on_creation
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1,
                                    :subject => 'Test', :author_id => 1)
                  issue.expects(:after_project_change).never
                  issue.save!
                end
                def test_should_not_call_after_project_change_on_update
                  issue = Issue.find(1)
                  issue.project = Project.find(1)
                  issue.subject = 'No project change'
                  issue.expects(:after_project_change).never
                  issue.save!
                end
                def test_should_call_after_project_change_on_project_change
                  issue = Issue.find(1)
                  issue.project = Project.find(2)
                  issue.expects(:after_project_change).once
                  issue.save!
                end
                def test_adding_journal_should_update_timestamp
                  issue = Issue.find(1)
                  updated_on_was = issue.updated_on
                  issue.init_journal(User.first, "Adding notes")
                  assert_difference 'Journal.count' do
                    assert issue.save
                  end
                  issue.reload
                  assert_not_equal updated_on_was, issue.updated_on
                end
                def test_should_close_duplicates
                  # Create 3 issues
                  issue1 = Issue.generate!
                  issue2 = Issue.generate!
                  issue3 = Issue.generate!
                  # 2 is a dupe of 1
                  IssueRelation.create!(:issue_from => issue2, :issue_to => issue1,
                                        :relation_type => IssueRelation::TYPE_DUPLICATES)
                  # And 3 is a dupe of 2
                  IssueRelation.create!(:issue_from => issue3, :issue_to => issue2,
                                        :relation_type => IssueRelation::TYPE_DUPLICATES)
                  # And 3 is a dupe of 1 (circular duplicates)
                  IssueRelation.create!(:issue_from => issue3, :issue_to => issue1,
                                        :relation_type => IssueRelation::TYPE_DUPLICATES)
                  assert issue1.reload.duplicates.include?(issue2)
                  # Closing issue 1
                  issue1.init_journal(User.first, "Closing issue1")
                  issue1.status = IssueStatus.where(:is_closed => true).first
                  assert issue1.save
                  # 2 and 3 should be also closed
                  assert issue2.reload.closed?
                  assert issue3.reload.closed?
                end
                def test_should_not_close_duplicated_issue
                  issue1 = Issue.generate!
                  issue2 = Issue.generate!
                  # 2 is a dupe of 1
                  IssueRelation.create(:issue_from => issue2, :issue_to => issue1,
                                       :relation_type => IssueRelation::TYPE_DUPLICATES)
                  # 2 is a dup of 1 but 1 is not a duplicate of 2
                  assert !issue2.reload.duplicates.include?(issue1)
                  # Closing issue 2
                  issue2.init_journal(User.first, "Closing issue2")
                  issue2.status = IssueStatus.where(:is_closed => true).first
                  assert issue2.save
                  # 1 should not be also closed
                  assert !issue1.reload.closed?
                end
                def test_assignable_versions
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                    :status_id => 1, :fixed_version_id => 1,
                                    :subject => 'New issue')
                  assert_equal ['open'], issue.assignable_versions.collect(&:status).uniq
                end
                def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                    :status_id => 1, :fixed_version_id => 1,
                                    :subject => 'New issue')
                  assert !issue.save
                  assert_not_nil issue.errors[:fixed_version_id]
                end
                def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                    :status_id => 1, :fixed_version_id => 2,
                                    :subject => 'New issue')
                  assert !issue.save
                  assert_not_nil issue.errors[:fixed_version_id]
                end
                def test_should_be_able_to_assign_a_new_issue_to_an_open_version
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                    :status_id => 1, :fixed_version_id => 3,
                                    :subject => 'New issue')
                  assert issue.save
                end
                def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version
                  issue = Issue.find(11)
                  assert_equal 'closed', issue.fixed_version.status
                  issue.subject = 'Subject changed'
                  assert issue.save
                end
                def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version
                  issue = Issue.find(11)
                  issue.status_id = 1
                  assert !issue.save
                  assert_not_nil issue.errors[:base]
                end
                def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version
                  issue = Issue.find(11)
                  issue.status_id = 1
                  issue.fixed_version_id = 3
                  assert issue.save
                end
                def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version
                  issue = Issue.find(12)
                  assert_equal 'locked', issue.fixed_version.status
                  issue.status_id = 1
                  assert issue.save
                end
                def test_should_not_be_able_to_keep_unshared_version_when_changing_project
                  issue = Issue.find(2)
                  assert_equal 2, issue.fixed_version_id
                  issue.project_id = 3
                  assert_nil issue.fixed_version_id
                  issue.fixed_version_id = 2
                  assert !issue.save
                  assert_include 'Target version is not included in the list', issue.errors.full_messages
                end
                def test_should_keep_shared_version_when_changing_project
                  Version.find(2).update_attribute :sharing, 'tree'
                  issue = Issue.find(2)
                  assert_equal 2, issue.fixed_version_id
                  issue.project_id = 3
                  assert_equal 2, issue.fixed_version_id
                  assert issue.save
                end
                def test_allowed_target_projects_on_move_should_include_projects_with_issue_tracking_enabled
                  assert_include Project.find(2), Issue.allowed_target_projects_on_move(User.find(2))
                end
                def test_allowed_target_projects_on_move_should_not_include_projects_with_issue_tracking_disabled
                  Project.find(2).disable_module! :issue_tracking
                  assert_not_include Project.find(2), Issue.allowed_target_projects_on_move(User.find(2))
                end
                def test_move_to_another_project_with_same_category
                  issue = Issue.find(1)
                  issue.project = Project.find(2)
                  assert issue.save
                  issue.reload
                  assert_equal 2, issue.project_id
                  # Category changes
                  assert_equal 4, issue.category_id
                  # Make sure time entries were move to the target project
                  assert_equal 2, issue.time_entries.first.project_id
                end
                def test_move_to_another_project_without_same_category
                  issue = Issue.find(2)
                  issue.project = Project.find(2)
                  assert issue.save
                  issue.reload
                  assert_equal 2, issue.project_id
                  # Category cleared
                  assert_nil issue.category_id
                end
                def test_move_to_another_project_should_clear_fixed_version_when_not_shared
                  issue = Issue.find(1)
                  issue.update_attribute(:fixed_version_id, 1)
                  issue.project = Project.find(2)
                  assert issue.save
                  issue.reload
                  assert_equal 2, issue.project_id
                  # Cleared fixed_version
                  assert_equal nil, issue.fixed_version
                end
                def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project
                  issue = Issue.find(1)
                  issue.update_attribute(:fixed_version_id, 4)
                  issue.project = Project.find(5)
                  assert issue.save
                  issue.reload
                  assert_equal 5, issue.project_id
                  # Keep fixed_version
                  assert_equal 4, issue.fixed_version_id
                end
                def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project
                  issue = Issue.find(1)
                  issue.update_attribute(:fixed_version_id, 1)
                  issue.project = Project.find(5)
                  assert issue.save
                  issue.reload
                  assert_equal 5, issue.project_id
                  # Cleared fixed_version
                  assert_equal nil, issue.fixed_version
                end
                def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide
                  issue = Issue.find(1)
                  issue.update_attribute(:fixed_version_id, 7)
                  issue.project = Project.find(2)
                  assert issue.save
                  issue.reload
                  assert_equal 2, issue.project_id
                  # Keep fixed_version
                  assert_equal 7, issue.fixed_version_id
                end
                def test_move_to_another_project_should_keep_parent_if_valid
                  issue = Issue.find(1)
                  issue.update_attribute(:parent_issue_id, 2)
                  issue.project = Project.find(3)
                  assert issue.save
                  issue.reload
                  assert_equal 2, issue.parent_id
                end
                def test_move_to_another_project_should_clear_parent_if_not_valid
                  issue = Issue.find(1)
                  issue.update_attribute(:parent_issue_id, 2)
                  issue.project = Project.find(2)
                  assert issue.save
                  issue.reload
                  assert_nil issue.parent_id
                end
                def test_move_to_another_project_with_disabled_tracker
                  issue = Issue.find(1)
                  target = Project.find(2)
                  target.tracker_ids = [3]
                  target.save
                  issue.project = target
                  assert issue.save
                  issue.reload
                  assert_equal 2, issue.project_id
                  assert_equal 3, issue.tracker_id
                end
                def test_copy_to_the_same_project
                  issue = Issue.find(1)
                  copy = issue.copy
                  assert_difference 'Issue.count' do
                    copy.save!
                  end
                  assert_kind_of Issue, copy
                  assert_equal issue.project, copy.project
                  assert_equal "125", copy.custom_value_for(2).value
                end
                def test_copy_to_another_project_and_tracker
                  issue = Issue.find(1)
                  copy = issue.copy(:project_id => 3, :tracker_id => 2)
                  assert_difference 'Issue.count' do
                    copy.save!
                  end
                  copy.reload
                  assert_kind_of Issue, copy
                  assert_equal Project.find(3), copy.project
                  assert_equal Tracker.find(2), copy.tracker
                  # Custom field #2 is not associated with target tracker
                  assert_nil copy.custom_value_for(2)
                end
-               context "#copy" do
-                 setup do
-                   @issue = Issue.find(1)
-                 end
-                 should "not create a journal" do
-                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)
-                   copy.save!
-                   assert_equal 0, copy.reload.journals.size
-                 end
+               test "#copy should not create a journal" do
+                 copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)
+                 copy.save!
+                 assert_equal 0, copy.reload.journals.size
+               end
-                 should "allow assigned_to changes" do
-                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)
-                   assert_equal 3, copy.assigned_to_id
-                 end
+               test "#copy should allow assigned_to changes" do
+                 copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)
+                 assert_equal 3, copy.assigned_to_id
+               end
-                 should "allow status changes" do
-                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :status_id => 2)
-                   assert_equal 2, copy.status_id
-                 end
+               test "#copy should allow status changes" do
+                 copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2, :status_id => 2)
+                 assert_equal 2, copy.status_id
+               end
-                 should "allow start date changes" do
-                   date = Date.today
-                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :start_date => date)
-                   assert_equal date, copy.start_date
-                 end
+               test "#copy should allow start date changes" do
+                 date = Date.today
+                 copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2, :start_date => date)
+                 assert_equal date, copy.start_date
+               end
-                 should "allow due date changes" do
-                   date = Date.today
-                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :due_date => date)
-                   assert_equal date, copy.due_date
-                 end
+               test "#copy should allow due date changes" do
+                 date = Date.today
+                 copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2, :due_date => date)
+                 assert_equal date, copy.due_date
+               end
-                 should "set current user as author" do
-                   User.current = User.find(9)
-                   copy = @issue.copy(:project_id => 3, :tracker_id => 2)
-                   assert_equal User.current, copy.author
-                 end
+               test "#copy should set current user as author" do
+                 User.current = User.find(9)
+                 copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2)
+                 assert_equal User.current, copy.author
+               end
-                 should "create a journal with notes" do
-                   date = Date.today
-                   notes = "Notes added when copying"
-                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :start_date => date)
-                   copy.init_journal(User.current, notes)
-                   copy.save!
+               test "#copy should create a journal with notes" do
+                 date = Date.today
+                 notes = "Notes added when copying"
+                 copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2, :start_date => date)
+                 copy.init_journal(User.current, notes)
+                 copy.save!
-                   assert_equal 1, copy.journals.size
-                   journal = copy.journals.first
-                   assert_equal 0, journal.details.size
-                   assert_equal notes, journal.notes
-                 end
+                 assert_equal 1, copy.journals.size
+                 journal = copy.journals.first
+                 assert_equal 0, journal.details.size
+                 assert_equal notes, journal.notes
                end
                def test_valid_parent_project
                  issue = Issue.find(1)
                  issue_in_same_project = Issue.find(2)
                  issue_in_child_project = Issue.find(5)
                  issue_in_grandchild_project = Issue.generate!(:project_id => 6, :tracker_id => 1)
                  issue_in_other_child_project = Issue.find(6)
                  issue_in_different_tree = Issue.find(4)
                  with_settings :cross_project_subtasks => '' do
                    assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                    assert_equal false, issue.valid_parent_project?(issue_in_child_project)
                    assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)
                    assert_equal false, issue.valid_parent_project?(issue_in_different_tree)
                  end
                  with_settings :cross_project_subtasks => 'system' do
                    assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                    assert_equal true, issue.valid_parent_project?(issue_in_child_project)
                    assert_equal true, issue.valid_parent_project?(issue_in_different_tree)
                  end
                  with_settings :cross_project_subtasks => 'tree' do
                    assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                    assert_equal true, issue.valid_parent_project?(issue_in_child_project)
                    assert_equal true, issue.valid_parent_project?(issue_in_grandchild_project)
                    assert_equal false, issue.valid_parent_project?(issue_in_different_tree)
                    assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_same_project)
                    assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)
                  end
                  with_settings :cross_project_subtasks => 'descendants' do
                    assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                    assert_equal false, issue.valid_parent_project?(issue_in_child_project)
                    assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)
                    assert_equal false, issue.valid_parent_project?(issue_in_different_tree)
                    assert_equal true, issue_in_child_project.valid_parent_project?(issue)
                    assert_equal false, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)
                  end
                end
                def test_recipients_should_include_previous_assignee
                  user = User.find(3)
                  user.members.update_all ["mail_notification = ?", false]
                  user.update_attribute :mail_notification, 'only_assigned'
                  issue = Issue.find(2)
                  issue.assigned_to = nil
                  assert_include user.mail, issue.recipients
                  issue.save!
                  assert !issue.recipients.include?(user.mail)
                end
                def test_recipients_should_not_include_users_that_cannot_view_the_issue
                  issue = Issue.find(12)
                  assert issue.recipients.include?(issue.author.mail)
                  # copy the issue to a private project
                  copy  = issue.copy(:project_id => 5, :tracker_id => 2)
                  # author is not a member of project anymore
                  assert !copy.recipients.include?(copy.author.mail)
                end
                def test_recipients_should_include_the_assigned_group_members
                  group_member = User.generate!
                  group = Group.generate!
                  group.users << group_member
                  issue = Issue.find(12)
                  issue.assigned_to = group
                  assert issue.recipients.include?(group_member.mail)
                end
                def test_watcher_recipients_should_not_include_users_that_cannot_view_the_issue
                  user = User.find(3)
                  issue = Issue.find(9)
                  Watcher.create!(:user => user, :watchable => issue)
                  assert issue.watched_by?(user)
                  assert !issue.watcher_recipients.include?(user.mail)
                end
                def test_issue_destroy
                  Issue.find(1).destroy
                  assert_nil Issue.find_by_id(1)
                  assert_nil TimeEntry.find_by_issue_id(1)
                end
                def test_destroying_a_deleted_issue_should_not_raise_an_error
                  issue = Issue.find(1)
                  Issue.find(1).destroy
                  assert_nothing_raised do
                    assert_no_difference 'Issue.count' do
                      issue.destroy
                    end
                    assert issue.destroyed?
                  end
                end
                def test_destroying_a_stale_issue_should_not_raise_an_error
                  issue = Issue.find(1)
                  Issue.find(1).update_attribute :subject, "Updated"
                  assert_nothing_raised do
                    assert_difference 'Issue.count', -1 do
                      issue.destroy
                    end
                    assert issue.destroyed?
                  end
                end
                def test_blocked
                  blocked_issue = Issue.find(9)
                  blocking_issue = Issue.find(10)
                  assert blocked_issue.blocked?
                  assert !blocking_issue.blocked?
                end
                def test_blocked_issues_dont_allow_closed_statuses
                  blocked_issue = Issue.find(9)
                  allowed_statuses = blocked_issue.new_statuses_allowed_to(users(:users_002))
                  assert !allowed_statuses.empty?
                  closed_statuses = allowed_statuses.select {|st| st.is_closed?}
                  assert closed_statuses.empty?
                end
                def test_unblocked_issues_allow_closed_statuses
                  blocking_issue = Issue.find(10)
                  allowed_statuses = blocking_issue.new_statuses_allowed_to(users(:users_002))
                  assert !allowed_statuses.empty?
                  closed_statuses = allowed_statuses.select {|st| st.is_closed?}
                  assert !closed_statuses.empty?
                end
                def test_reschedule_an_issue_without_dates
                  with_settings :non_working_week_days => [] do
                    issue = Issue.new(:start_date => nil, :due_date => nil)
                    issue.reschedule_on '2012-10-09'.to_date
                    assert_equal '2012-10-09'.to_date, issue.start_date
                    assert_equal '2012-10-09'.to_date, issue.due_date
                  end
                  with_settings :non_working_week_days => %w(6 7) do
                    issue = Issue.new(:start_date => nil, :due_date => nil)
                    issue.reschedule_on '2012-10-09'.to_date
                    assert_equal '2012-10-09'.to_date, issue.start_date
                    assert_equal '2012-10-09'.to_date, issue.due_date
                    issue = Issue.new(:start_date => nil, :due_date => nil)
                    issue.reschedule_on '2012-10-13'.to_date
                    assert_equal '2012-10-15'.to_date, issue.start_date
                    assert_equal '2012-10-15'.to_date, issue.due_date
                  end
                end
                def test_reschedule_an_issue_with_start_date
                  with_settings :non_working_week_days => [] do
                    issue = Issue.new(:start_date => '2012-10-09', :due_date => nil)
                    issue.reschedule_on '2012-10-13'.to_date
                    assert_equal '2012-10-13'.to_date, issue.start_date
                    assert_equal '2012-10-13'.to_date, issue.due_date
                  end
                  with_settings :non_working_week_days => %w(6 7) do
                    issue = Issue.new(:start_date => '2012-10-09', :due_date => nil)
                    issue.reschedule_on '2012-10-11'.to_date
                    assert_equal '2012-10-11'.to_date, issue.start_date
                    assert_equal '2012-10-11'.to_date, issue.due_date
                    issue = Issue.new(:start_date => '2012-10-09', :due_date => nil)
                    issue.reschedule_on '2012-10-13'.to_date
                    assert_equal '2012-10-15'.to_date, issue.start_date
                    assert_equal '2012-10-15'.to_date, issue.due_date
                  end
                end
                def test_reschedule_an_issue_with_start_and_due_dates
                  with_settings :non_working_week_days => [] do
                    issue = Issue.new(:start_date => '2012-10-09', :due_date => '2012-10-15')
                    issue.reschedule_on '2012-10-13'.to_date
                    assert_equal '2012-10-13'.to_date, issue.start_date
                    assert_equal '2012-10-19'.to_date, issue.due_date
                  end
                  with_settings :non_working_week_days => %w(6 7) do
                    issue = Issue.new(:start_date => '2012-10-09', :due_date => '2012-10-19') # 8 working days
                    issue.reschedule_on '2012-10-11'.to_date
                    assert_equal '2012-10-11'.to_date, issue.start_date
                    assert_equal '2012-10-23'.to_date, issue.due_date
                    issue = Issue.new(:start_date => '2012-10-09', :due_date => '2012-10-19')
                    issue.reschedule_on '2012-10-13'.to_date
                    assert_equal '2012-10-15'.to_date, issue.start_date
                    assert_equal '2012-10-25'.to_date, issue.due_date
                  end
                end
                def test_rescheduling_an_issue_to_a_later_due_date_should_reschedule_following_issue
                  issue1 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                  issue2 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                  IssueRelation.create!(:issue_from => issue1, :issue_to => issue2,
                                        :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert_equal Date.parse('2012-10-18'), issue2.reload.start_date
                  issue1.due_date = '2012-10-23'
                  issue1.save!
                  issue2.reload
                  assert_equal Date.parse('2012-10-24'), issue2.start_date
                  assert_equal Date.parse('2012-10-26'), issue2.due_date
                end
                def test_rescheduling_an_issue_to_an_earlier_due_date_should_reschedule_following_issue
                  issue1 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                  issue2 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                  IssueRelation.create!(:issue_from => issue1, :issue_to => issue2,
                                        :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert_equal Date.parse('2012-10-18'), issue2.reload.start_date
                  issue1.start_date = '2012-09-17'
                  issue1.due_date = '2012-09-18'
                  issue1.save!
                  issue2.reload
                  assert_equal Date.parse('2012-09-19'), issue2.start_date
                  assert_equal Date.parse('2012-09-21'), issue2.due_date
                end
                def test_rescheduling_reschedule_following_issue_earlier_should_consider_other_preceding_issues
                  issue1 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                  issue2 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                  issue3 = Issue.generate!(:start_date => '2012-10-01', :due_date => '2012-10-02')
                  IssueRelation.create!(:issue_from => issue1, :issue_to => issue2,
                                        :relation_type => IssueRelation::TYPE_PRECEDES)
                  IssueRelation.create!(:issue_from => issue3, :issue_to => issue2,
                                        :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert_equal Date.parse('2012-10-18'), issue2.reload.start_date
                  issue1.start_date = '2012-09-17'
                  issue1.due_date = '2012-09-18'
                  issue1.save!
                  issue2.reload
                  # Issue 2 must start after Issue 3
                  assert_equal Date.parse('2012-10-03'), issue2.start_date
                  assert_equal Date.parse('2012-10-05'), issue2.due_date
                end
                def test_rescheduling_a_stale_issue_should_not_raise_an_error
                  with_settings :non_working_week_days => [] do
                    stale = Issue.find(1)
                    issue = Issue.find(1)
                    issue.subject = "Updated"
                    issue.save!
                    date = 10.days.from_now.to_date
                    assert_nothing_raised do
                      stale.reschedule_on!(date)
                    end
                    assert_equal date, stale.reload.start_date
                  end
                end
                def test_overdue
                  assert Issue.new(:due_date => 1.day.ago.to_date).overdue?
                  assert !Issue.new(:due_date => Date.today).overdue?
                  assert !Issue.new(:due_date => 1.day.from_now.to_date).overdue?
                  assert !Issue.new(:due_date => nil).overdue?
                  assert !Issue.new(:due_date => 1.day.ago.to_date,
                                    :status => IssueStatus.where(:is_closed => true).first
                                    ).overdue?
                end
-               context "#behind_schedule?" do
-                 should "be false if the issue has no start_date" do
-                   assert !Issue.new(:start_date => nil,
-                                     :due_date => 1.day.from_now.to_date,
-                                     :done_ratio => 0).behind_schedule?
-                 end
+               test "#behind_schedule? should be false if the issue has no start_date" do
+                 assert !Issue.new(:start_date => nil,
+                                   :due_date => 1.day.from_now.to_date,
+                                   :done_ratio => 0).behind_schedule?
+               end
-                 should "be false if the issue has no end_date" do
-                   assert !Issue.new(:start_date => 1.day.from_now.to_date,
-                                     :due_date => nil,
-                                     :done_ratio => 0).behind_schedule?
-                 end
+               test "#behind_schedule? should be false if the issue has no end_date" do
+                 assert !Issue.new(:start_date => 1.day.from_now.to_date,
+                                   :due_date => nil,
+                                   :done_ratio => 0).behind_schedule?
+               end
-                 should "be false if the issue has more done than it's calendar time" do
-                   assert !Issue.new(:start_date => 50.days.ago.to_date,
-                                     :due_date => 50.days.from_now.to_date,
-                                     :done_ratio => 90).behind_schedule?
-                 end
+               test "#behind_schedule? should be false if the issue has more done than it's calendar time" do
+                 assert !Issue.new(:start_date => 50.days.ago.to_date,
+                                   :due_date => 50.days.from_now.to_date,
+                                   :done_ratio => 90).behind_schedule?
+               end
-                 should "be true if the issue hasn't been started at all" do
-                   assert Issue.new(:start_date => 1.day.ago.to_date,
-                                    :due_date => 1.day.from_now.to_date,
-                                    :done_ratio => 0).behind_schedule?
-                 end
+               test "#behind_schedule? should be true if the issue hasn't been started at all" do
+                 assert Issue.new(:start_date => 1.day.ago.to_date,
+                                  :due_date => 1.day.from_now.to_date,
+                                  :done_ratio => 0).behind_schedule?
+               end
-                 should "be true if the issue has used more calendar time than it's done ratio" do
-                   assert Issue.new(:start_date => 100.days.ago.to_date,
-                                    :due_date => Date.today,
-                                    :done_ratio => 90).behind_schedule?
-                 end
+               test "#behind_schedule? should be true if the issue has used more calendar time than it's done ratio" do
+                 assert Issue.new(:start_date => 100.days.ago.to_date,
+                                  :due_date => Date.today,
+                                  :done_ratio => 90).behind_schedule?
                end
-               context "#assignable_users" do
-                 should "be Users" do
-                   assert_kind_of User, Issue.find(1).assignable_users.first
-                 end
+               test "#assignable_users should be Users" do
+                 assert_kind_of User, Issue.find(1).assignable_users.first
+               end
-                 should "include the issue author" do
-                   non_project_member = User.generate!
-                   issue = Issue.generate!(:author => non_project_member)
+               test "#assignable_users should include the issue author" do
+                 non_project_member = User.generate!
+                 issue = Issue.generate!(:author => non_project_member)
-                   assert issue.assignable_users.include?(non_project_member)
-                 end
+                 assert issue.assignable_users.include?(non_project_member)
+               end
-                 should "include the current assignee" do
-                   user = User.generate!
-                   issue = Issue.generate!(:assigned_to => user)
-                   user.lock!
+               test "#assignable_users should include the current assignee" do
+                 user = User.generate!
+                 issue = Issue.generate!(:assigned_to => user)
+                 user.lock!
-                   assert Issue.find(issue.id).assignable_users.include?(user)
-                 end
+                 assert Issue.find(issue.id).assignable_users.include?(user)
+               end
-                 should "not show the issue author twice" do
-                   assignable_user_ids = Issue.find(1).assignable_users.collect(&:id)
-                   assert_equal 2, assignable_user_ids.length
+               test "#assignable_users should not show the issue author twice" do
+                 assignable_user_ids = Issue.find(1).assignable_users.collect(&:id)
+                 assert_equal 2, assignable_user_ids.length
-                   assignable_user_ids.each do |user_id|
-                     assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length,
-                                  "User #{user_id} appears more or less than once"
-                   end
+                 assignable_user_ids.each do |user_id|
+                   assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length,
+                                "User #{user_id} appears more or less than once"
                  end
+               end
-                 context "with issue_group_assignment" do
-                   should "include groups" do
-                     issue = Issue.new(:project => Project.find(2))
+               test "#assignable_users with issue_group_assignment should include groups" do
+                 issue = Issue.new(:project => Project.find(2))
-                     with_settings :issue_group_assignment => '1' do
-                       assert_equal %w(Group User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
-                       assert issue.assignable_users.include?(Group.find(11))
-                     end
-                   end
+                 with_settings :issue_group_assignment => '1' do
+                   assert_equal %w(Group User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
+                   assert issue.assignable_users.include?(Group.find(11))
                  end
+               end
-                 context "without issue_group_assignment" do
-                   should "not include groups" do
-                     issue = Issue.new(:project => Project.find(2))
+               test "#assignable_users without issue_group_assignment should not include groups" do
+                 issue = Issue.new(:project => Project.find(2))
-                     with_settings :issue_group_assignment => '0' do
-                       assert_equal %w(User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
-                       assert !issue.assignable_users.include?(Group.find(11))
-                     end
-                   end
+                 with_settings :issue_group_assignment => '0' do
+                   assert_equal %w(User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
+                   assert !issue.assignable_users.include?(Group.find(11))
                  end
                end
                def test_create_should_send_email_notification
                  ActionMailer::Base.deliveries.clear
                  issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                    :author_id => 3, :status_id => 1,
                                    :priority => IssuePriority.all.first,
                                    :subject => 'test_create', :estimated_hours => '1:30')
                  assert issue.save
                  assert_equal 1, ActionMailer::Base.deliveries.size
                end
                def test_stale_issue_should_not_send_email_notification
                  ActionMailer::Base.deliveries.clear
                  issue = Issue.find(1)
                  stale = Issue.find(1)
                  issue.init_journal(User.find(1))
                  issue.subject = 'Subjet update'
                  assert issue.save
                  assert_equal 1, ActionMailer::Base.deliveries.size
                  ActionMailer::Base.deliveries.clear
                  stale.init_journal(User.find(1))
                  stale.subject = 'Another subjet update'
                  assert_raise ActiveRecord::StaleObjectError do
                    stale.save
                  end
                  assert ActionMailer::Base.deliveries.empty?
                end
                def test_journalized_description
                  IssueCustomField.delete_all
                  i = Issue.first
                  old_description = i.description
                  new_description = "This is the new description"
                  i.init_journal(User.find(2))
                  i.description = new_description
                  assert_difference 'Journal.count', 1 do
                    assert_difference 'JournalDetail.count', 1 do
                      i.save!
                    end
                  end
                  detail = JournalDetail.first(:order => 'id DESC')
                  assert_equal i, detail.journal.journalized
                  assert_equal 'attr', detail.property
                  assert_equal 'description', detail.prop_key
                  assert_equal old_description, detail.old_value
                  assert_equal new_description, detail.value
                end
                def test_blank_descriptions_should_not_be_journalized
                  IssueCustomField.delete_all
                  Issue.update_all("description = NULL", "id=1")
                  i = Issue.find(1)
                  i.init_journal(User.find(2))
                  i.subject = "blank description"
                  i.description = "\r\n"
                  assert_difference 'Journal.count', 1 do
                    assert_difference 'JournalDetail.count', 1 do
                      i.save!
                    end
                  end
                end
                def test_journalized_multi_custom_field
                  field = IssueCustomField.create!(:name => 'filter', :field_format => 'list',
                                                   :is_filter => true, :is_for_all => true,
                                                   :tracker_ids => [1],
                                                   :possible_values => ['value1', 'value2', 'value3'],
                                                   :multiple => true)
                  issue = Issue.create!(:project_id => 1, :tracker_id => 1,
                                        :subject => 'Test', :author_id => 1)
                  assert_difference 'Journal.count' do
                    assert_difference 'JournalDetail.count' do
                      issue.init_journal(User.first)
                      issue.custom_field_values = {field.id => ['value1']}
                      issue.save!
                    end
                    assert_difference 'JournalDetail.count' do
                      issue.init_journal(User.first)
                      issue.custom_field_values = {field.id => ['value1', 'value2']}
                      issue.save!
                    end
                    assert_difference 'JournalDetail.count', 2 do
                      issue.init_journal(User.first)
                      issue.custom_field_values = {field.id => ['value3', 'value2']}
                      issue.save!
                    end
                    assert_difference 'JournalDetail.count', 2 do
                      issue.init_journal(User.first)
                      issue.custom_field_values = {field.id => nil}
                      issue.save!
                    end
                  end
                end
                def test_description_eol_should_be_normalized
                  i = Issue.new(:description => "CR \r LF \n CRLF \r\n")
                  assert_equal "CR \r\n LF \r\n CRLF \r\n", i.description
                end
                def test_saving_twice_should_not_duplicate_journal_details
                  i = Issue.first
                  i.init_journal(User.find(2), 'Some notes')
                  # initial changes
                  i.subject = 'New subject'
                  i.done_ratio = i.done_ratio + 10
                  assert_difference 'Journal.count' do
                    assert i.save
                  end
                  # 1 more change
                  i.priority = IssuePriority.where("id <> ?", i.priority_id).first
                  assert_no_difference 'Journal.count' do
                    assert_difference 'JournalDetail.count', 1 do
                      i.save
                    end
                  end
                  # no more change
                  assert_no_difference 'Journal.count' do
                    assert_no_difference 'JournalDetail.count' do
                      i.save
                    end
                  end
                end
                def test_all_dependent_issues
                  IssueRelation.delete_all
                  assert IssueRelation.create!(:issue_from => Issue.find(1),
                                               :issue_to   => Issue.find(2),
                                               :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert IssueRelation.create!(:issue_from => Issue.find(2),
                                               :issue_to   => Issue.find(3),
                                               :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert IssueRelation.create!(:issue_from => Issue.find(3),
                                               :issue_to   => Issue.find(8),
                                               :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
                end
                def test_all_dependent_issues_with_persistent_circular_dependency
                  IssueRelation.delete_all
                  assert IssueRelation.create!(:issue_from => Issue.find(1),
                                               :issue_to   => Issue.find(2),
                                               :relation_type => IssueRelation::TYPE_PRECEDES)
                  assert IssueRelation.create!(:issue_from => Issue.find(2),
                                               :issue_to   => Issue.find(3),
                                               :relation_type => IssueRelation::TYPE_PRECEDES)
                  r = IssueRelation.create!(:issue_from => Issue.find(3),
                                           :issue_to   => Issue.find(7),
                                           :relation_type => IssueRelation::TYPE_PRECEDES)
                  IssueRelation.update_all("issue_to_id = 1", ["id = ?", r.id])
                  assert_equal [2, 3], Issue.find(1).all_dependent_issues.collect(&:id).sort
                end
                def test_all_dependent_issues_with_persistent_multiple_circular_dependencies
                  IssueRelation.delete_all
                  assert IssueRelation.create!(:issue_from => Issue.find(1),
                                               :issue_to   => Issue.find(2),
                                               :relation_type => IssueRelation::TYPE_RELATES)
                  assert IssueRelation.create!(:issue_from => Issue.find(2),
                                               :issue_to   => Issue.find(3),
                                               :relation_type => IssueRelation::TYPE_RELATES)
                  assert IssueRelation.create!(:issue_from => Issue.find(3),
                                               :issue_to   => Issue.find(8),
                                               :relation_type => IssueRelation::TYPE_RELATES)
                  r = IssueRelation.create!(:issue_from => Issue.find(8),
                                           :issue_to   => Issue.find(7),
                                           :relation_type => IssueRelation::TYPE_RELATES)
                  IssueRelation.update_all("issue_to_id = 2", ["id = ?", r.id])
                  r = IssueRelation.create!(:issue_from => Issue.find(3),
                                           :issue_to   => Issue.find(7),
                                           :relation_type => IssueRelation::TYPE_RELATES)
                  IssueRelation.update_all("issue_to_id = 1", ["id = ?", r.id])
                  assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
                end
-               context "#done_ratio" do
-                 setup do
-                   @issue = Issue.find(1)
-                   @issue_status = IssueStatus.find(1)
-                   @issue_status.update_attribute(:default_done_ratio, 50)
-                   @issue2 = Issue.find(2)
-                   @issue_status2 = IssueStatus.find(2)
-                   @issue_status2.update_attribute(:default_done_ratio, 0)
-                 end
+               test "#done_ratio should use the issue_status according to Setting.issue_done_ratio" do
+                 @issue = Issue.find(1)
+                 @issue_status = IssueStatus.find(1)
+                 @issue_status.update_attribute(:default_done_ratio, 50)
+                 @issue2 = Issue.find(2)
+                 @issue_status2 = IssueStatus.find(2)
+                 @issue_status2.update_attribute(:default_done_ratio, 0)
-                 teardown do
-                   Setting.issue_done_ratio = 'issue_field'
+                 with_settings :issue_done_ratio => 'issue_field' do
+                   assert_equal 0, @issue.done_ratio
+                   assert_equal 30, @issue2.done_ratio
                  end
-                 context "with Setting.issue_done_ratio using the issue_field" do
-                   setup do
-                     Setting.issue_done_ratio = 'issue_field'
-                   end
-                   should "read the issue's field" do
-                     assert_equal 0, @issue.done_ratio
-                     assert_equal 30, @issue2.done_ratio
-                   end
-                 end
-                 context "with Setting.issue_done_ratio using the issue_status" do
-                   setup do
-                     Setting.issue_done_ratio = 'issue_status'
-                   end
-                   should "read the Issue Status's default done ratio" do
-                     assert_equal 50, @issue.done_ratio
-                     assert_equal 0, @issue2.done_ratio
-                   end
+                 with_settings :issue_done_ratio => 'issue_status' do
+                   assert_equal 50, @issue.done_ratio
+                   assert_equal 0, @issue2.done_ratio
                  end
                end
-               context "#update_done_ratio_from_issue_status" do
-                 setup do
-                   @issue = Issue.find(1)
-                   @issue_status = IssueStatus.find(1)
-                   @issue_status.update_attribute(:default_done_ratio, 50)
-                   @issue2 = Issue.find(2)
-                   @issue_status2 = IssueStatus.find(2)
-                   @issue_status2.update_attribute(:default_done_ratio, 0)
-                 end
-                 context "with Setting.issue_done_ratio using the issue_field" do
-                   setup do
-                     Setting.issue_done_ratio = 'issue_field'
-                   end
+               test "#update_done_ratio_from_issue_status should update done_ratio according to Setting.issue_done_ratio" do
+                 @issue = Issue.find(1)
+                 @issue_status = IssueStatus.find(1)
+                 @issue_status.update_attribute(:default_done_ratio, 50)
+                 @issue2 = Issue.find(2)
+                 @issue_status2 = IssueStatus.find(2)
+                 @issue_status2.update_attribute(:default_done_ratio, 0)
-                   should "not change the issue" do
-                     @issue.update_done_ratio_from_issue_status
-                     @issue2.update_done_ratio_from_issue_status
+                 with_settings :issue_done_ratio => 'issue_field' do
+                   @issue.update_done_ratio_from_issue_status
+                   @issue2.update_done_ratio_from_issue_status
-                     assert_equal 0, @issue.read_attribute(:done_ratio)
-                     assert_equal 30, @issue2.read_attribute(:done_ratio)
-                   end
+                   assert_equal 0, @issue.read_attribute(:done_ratio)
+                   assert_equal 30, @issue2.read_attribute(:done_ratio)
                  end
-                 context "with Setting.issue_done_ratio using the issue_status" do
-                   setup do
-                     Setting.issue_done_ratio = 'issue_status'
-                   end
-                   should "change the issue's done ratio" do
-                     @issue.update_done_ratio_from_issue_status
-                     @issue2.update_done_ratio_from_issue_status
+                 with_settings :issue_done_ratio => 'issue_status' do
+                   @issue.update_done_ratio_from_issue_status
+                   @issue2.update_done_ratio_from_issue_status
-                     assert_equal 50, @issue.read_attribute(:done_ratio)
-                     assert_equal 0, @issue2.read_attribute(:done_ratio)
-                   end
+                   assert_equal 50, @issue.read_attribute(:done_ratio)
+                   assert_equal 0, @issue2.read_attribute(:done_ratio)
                  end
                end
                test "#by_tracker" do
                  User.current = User.anonymous
                  groups = Issue.by_tracker(Project.find(1))
                  assert_equal 3, groups.size
                  assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_version" do
                  User.current = User.anonymous
                  groups = Issue.by_version(Project.find(1))
                  assert_equal 3, groups.size
                  assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_priority" do
                  User.current = User.anonymous
                  groups = Issue.by_priority(Project.find(1))
                  assert_equal 4, groups.size
                  assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_category" do
                  User.current = User.anonymous
                  groups = Issue.by_category(Project.find(1))
                  assert_equal 2, groups.size
                  assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_assigned_to" do
                  User.current = User.anonymous
                  groups = Issue.by_assigned_to(Project.find(1))
                  assert_equal 2, groups.size
                  assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_author" do
                  User.current = User.anonymous
                  groups = Issue.by_author(Project.find(1))
                  assert_equal 4, groups.size
                  assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                test "#by_subproject" do
                  User.current = User.anonymous
                  groups = Issue.by_subproject(Project.find(1))
                  # Private descendant not visible
                  assert_equal 1, groups.size
                  assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}
                end
                def test_recently_updated_scope
                  #should return the last updated issue
                  assert_equal Issue.reorder("updated_on DESC").first, Issue.recently_updated.limit(1).first
                end
                def test_on_active_projects_scope
                  assert Project.find(2).archive
                  before = Issue.on_active_project.length
                  # test inclusion to results
                  issue = Issue.generate!(:tracker => Project.find(2).trackers.first)
                  assert_equal before + 1, Issue.on_active_project.length
                  # Move to an archived project
                  issue.project = Project.find(2)
                  assert issue.save
                  assert_equal before, Issue.on_active_project.length
                end
-               context "Issue#recipients" do
-                 setup do
-                   @project = Project.find(1)
-                   @author = User.generate!
-                   @assignee = User.generate!
-                   @issue = Issue.generate!(:project => @project, :assigned_to => @assignee, :author => @author)
-                 end
-                 should "include project recipients" do
-                   assert @project.recipients.present?
-                   @project.recipients.each do |project_recipient|
-                     assert @issue.recipients.include?(project_recipient)
-                   end
-                 end
-                 should "include the author if the author is active" do
-                   assert @issue.author, "No author set for Issue"
-                   assert @issue.recipients.include?(@issue.author.mail)
-                 end
-                 should "include the assigned to user if the assigned to user is active" do
-                   assert @issue.assigned_to, "No assigned_to set for Issue"
-                   assert @issue.recipients.include?(@issue.assigned_to.mail)
+               test "Issue#recipients should include project recipients" do
+                 issue = Issue.generate!
+                 assert issue.project.recipients.present?
+                 issue.project.recipients.each do |project_recipient|
+                   assert issue.recipients.include?(project_recipient)
                  end
+               end
-                 should "not include users who opt out of all email" do
-                   @author.update_attribute(:mail_notification, :none)
-                   assert !@issue.recipients.include?(@issue.author.mail)
-                 end
+               test "Issue#recipients should include the author if the author is active" do
+                 issue = Issue.generate!(:author => User.generate!)
+                 assert issue.author, "No author set for Issue"
+                 assert issue.recipients.include?(issue.author.mail)
+               end
-                 should "not include the issue author if they are only notified of assigned issues" do
-                   @author.update_attribute(:mail_notification, :only_assigned)
+               test "Issue#recipients should include the assigned to user if the assigned to user is active" do
+                 issue = Issue.generate!(:assigned_to => User.generate!)
+                 assert issue.assigned_to, "No assigned_to set for Issue"
+                 assert issue.recipients.include?(issue.assigned_to.mail)
+               end
-                   assert !@issue.recipients.include?(@issue.author.mail)
-                 end
+               test "Issue#recipients should not include users who opt out of all email" do
+                 issue = Issue.generate!(:author => User.generate!)
+                 issue.author.update_attribute(:mail_notification, :none)
+                 assert !issue.recipients.include?(issue.author.mail)
+               end
-                 should "not include the assigned user if they are only notified of owned issues" do
-                   @assignee.update_attribute(:mail_notification, :only_owner)
+               test "Issue#recipients should not include the issue author if they are only notified of assigned issues" do
+                 issue = Issue.generate!(:author => User.generate!)
+                 issue.author.update_attribute(:mail_notification, :only_assigned)
+                 assert !issue.recipients.include?(issue.author.mail)
+               end
-                   assert !@issue.recipients.include?(@issue.assigned_to.mail)
-                 end
+               test "Issue#recipients should not include the assigned user if they are only notified of owned issues" do
+                 issue = Issue.generate!(:assigned_to => User.generate!)
+                 issue.assigned_to.update_attribute(:mail_notification, :only_owner)
+                 assert !issue.recipients.include?(issue.assigned_to.mail)
                end
                def test_last_journal_id_with_journals_should_return_the_journal_id
                  assert_equal 2, Issue.find(1).last_journal_id
                end
                def test_last_journal_id_without_journals_should_return_nil
                  assert_nil Issue.find(3).last_journal_id
                end
                def test_journals_after_should_return_journals_with_greater_id
                  assert_equal [Journal.find(2)], Issue.find(1).journals_after('1')
                  assert_equal [], Issue.find(1).journals_after('2')
                end
                def test_journals_after_with_blank_arg_should_return_all_journals
                  assert_equal [Journal.find(1), Journal.find(2)], Issue.find(1).journals_after('')
                end
                def test_css_classes_should_include_priority
                  issue = Issue.new(:priority => IssuePriority.find(8))
                  classes = issue.css_classes.split(' ')
                  assert_include 'priority-8', classes
                  assert_include 'priority-highest', classes
                end
                def test_save_attachments_with_hash_should_save_attachments_in_keys_order
                  set_tmp_attachments_directory
                  issue = Issue.generate!
                  issue.save_attachments({
                    'p0' => {'file' => mock_file_with_options(:original_filename => 'upload')},
                    '3' => {'file' => mock_file_with_options(:original_filename => 'bar')},
                    '1' => {'file' => mock_file_with_options(:original_filename => 'foo')}
                  })
                  issue.attach_saved_attachments
                  assert_equal 3, issue.reload.attachments.count
                  assert_equal %w(upload foo bar), issue.attachments.map(&:filename)
                end
              end

test/unit/mail_handler_test.rb +41 -59

              # encoding: utf-8
              #
              # Redmine - project management software
              # Copyright (C) 2006-2013  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__)
              class MailHandlerTest < ActiveSupport::TestCase
                fixtures :users, :projects, :enabled_modules, :roles,
                         :members, :member_roles, :users,
                         :issues, :issue_statuses,
                         :workflows, :trackers, :projects_trackers,
                         :versions, :enumerations, :issue_categories,
                         :custom_fields, :custom_fields_trackers, :custom_fields_projects,
                         :boards, :messages
                FIXTURES_PATH = File.dirname(__FILE__) + '/../fixtures/mail_handler'
                def setup
                  ActionMailer::Base.deliveries.clear
                  Setting.notified_events = Redmine::Notifiable.all.collect(&:name)
                end
                def teardown
                  Setting.clear_cache
                end
                def test_add_issue
                  ActionMailer::Base.deliveries.clear
                  # This email contains: 'Project: onlinestore'
                  issue = submit_email('ticket_on_given_project.eml')
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal Project.find(2), issue.project
                  assert_equal issue.project.trackers.first, issue.tracker
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal IssueStatus.find_by_name('Resolved'), issue.status
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                  assert_equal '2010-01-01', issue.start_date.to_s
                  assert_equal '2010-12-31', issue.due_date.to_s
                  assert_equal User.find_by_login('jsmith'), issue.assigned_to
                  assert_equal Version.find_by_name('Alpha'), issue.fixed_version
                  assert_equal 2.5, issue.estimated_hours
                  assert_equal 30, issue.done_ratio
                  assert_equal [issue.id, 1, 2], [issue.root_id, issue.lft, issue.rgt]
                  # keywords should be removed from the email body
                  assert !issue.description.match(/^Project:/i)
                  assert !issue.description.match(/^Status:/i)
                  assert !issue.description.match(/^Start Date:/i)
                  # Email notification should be sent
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  assert mail.subject.include?('New ticket on a given project')
                end
                def test_add_issue_with_default_tracker
                  # This email contains: 'Project: onlinestore'
                  issue = submit_email(
                            'ticket_on_given_project.eml',
                            :issue => {:tracker => 'Support request'}
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'Support request', issue.tracker.name
                end
                def test_add_issue_with_status
                  # This email contains: 'Project: onlinestore' and 'Status: Resolved'
                  issue = submit_email('ticket_on_given_project.eml')
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal Project.find(2), issue.project
                  assert_equal IssueStatus.find_by_name("Resolved"), issue.status
                end
                def test_add_issue_with_attributes_override
                  issue = submit_email(
                            'ticket_with_attributes.eml',
                            :allow_override => 'tracker,category,priority'
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'Feature request', issue.tracker.to_s
                  assert_equal 'Stock management', issue.category.to_s
                  assert_equal 'Urgent', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_group_assignment
                  with_settings :issue_group_assignment => '1' do
                    issue = submit_email('ticket_on_given_project.eml') do |email|
                      email.gsub!('Assigned to: John Smith', 'Assigned to: B Team')
                    end
                    assert issue.is_a?(Issue)
                    assert !issue.new_record?
                    issue.reload
                    assert_equal Group.find(11), issue.assigned_to
                  end
                end
                def test_add_issue_with_partial_attributes_override
                  issue = submit_email(
                            'ticket_with_attributes.eml',
                            :issue => {:priority => 'High'},
                            :allow_override => ['tracker']
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'Feature request', issue.tracker.to_s
                  assert_nil issue.category
                  assert_equal 'High', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_spaces_between_attribute_and_separator
                  issue = submit_email(
                            'ticket_with_spaces_between_attribute_and_separator.eml',
                            :allow_override => 'tracker,category,priority'
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'Feature request', issue.tracker.to_s
                  assert_equal 'Stock management', issue.category.to_s
                  assert_equal 'Urgent', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_attachment_to_specific_project
                  issue = submit_email('ticket_with_attachment.eml', :issue => {:project => 'onlinestore'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'Ticket created by email with attachment', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'This is  a new ticket with attachments', issue.description
                  # Attachment properties
                  assert_equal 1, issue.attachments.size
                  assert_equal 'Paella.jpg', issue.attachments.first.filename
                  assert_equal 'image/jpeg', issue.attachments.first.content_type
                  assert_equal 10790, issue.attachments.first.filesize
                end
                def test_add_issue_with_custom_fields
                  issue = submit_email('ticket_with_custom_fields.eml', :issue => {:project => 'onlinestore'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket with custom field values', issue.subject
                  assert_equal 'PostgreSQL', issue.custom_field_value(1)
                  assert_equal 'Value for a custom field', issue.custom_field_value(2)
                  assert !issue.description.match(/^searchable field:/i)
                end
                def test_add_issue_with_version_custom_fields
                  field = IssueCustomField.create!(:name => 'Affected version', :field_format => 'version', :is_for_all => true, :tracker_ids => [1,2,3])
                  issue = submit_email('ticket_with_custom_fields.eml', :issue => {:project => 'ecookbook'}) do |email|
                    email << "Affected version: 1.0\n"
                  end
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal '2', issue.custom_field_value(field)
                end
                def test_add_issue_should_match_assignee_on_display_name
                  user = User.generate!(:firstname => 'Foo Bar', :lastname => 'Foo Baz')
                  User.add_to_project(user, Project.find(2))
                  issue = submit_email('ticket_on_given_project.eml') do |email|
                    email.sub!(/^Assigned to.*$/, 'Assigned to: Foo Bar Foo baz')
                  end
                  assert issue.is_a?(Issue)
                  assert_equal user, issue.assigned_to
                end
                def test_add_issue_with_cc
                  issue = submit_email('ticket_with_cc.eml', :issue => {:project => 'ecookbook'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert issue.watched_by?(User.find_by_mail('dlopper@somenet.foo'))
                  assert_equal 1, issue.watcher_user_ids.size
                end
                def test_add_issue_by_unknown_user
                  assert_no_difference 'User.count' do
                    assert_equal false,
                                 submit_email(
                                   'ticket_by_unknown_user.eml',
                                   :issue => {:project => 'ecookbook'}
                                 )
                  end
                end
                def test_add_issue_by_anonymous_user
                  Role.anonymous.add_permission!(:add_issues)
                  assert_no_difference 'User.count' do
                    issue = submit_email(
                              'ticket_by_unknown_user.eml',
                              :issue => {:project => 'ecookbook'},
                              :unknown_user => 'accept'
                            )
                    assert issue.is_a?(Issue)
                    assert issue.author.anonymous?
                  end
                end
                def test_add_issue_by_anonymous_user_with_no_from_address
                  Role.anonymous.add_permission!(:add_issues)
                  assert_no_difference 'User.count' do
                    issue = submit_email(
                              'ticket_by_empty_user.eml',
                              :issue => {:project => 'ecookbook'},
                              :unknown_user => 'accept'
                            )
                    assert issue.is_a?(Issue)
                    assert issue.author.anonymous?
                  end
                end
                def test_add_issue_by_anonymous_user_on_private_project
                  Role.anonymous.add_permission!(:add_issues)
                  assert_no_difference 'User.count' do
                    assert_no_difference 'Issue.count' do
                      assert_equal false,
                                   submit_email(
                                     'ticket_by_unknown_user.eml',
                                     :issue => {:project => 'onlinestore'},
                                     :unknown_user => 'accept'
                                   )
                    end
                  end
                end
                def test_add_issue_by_anonymous_user_on_private_project_without_permission_check
                  assert_no_difference 'User.count' do
                    assert_difference 'Issue.count' do
                      issue = submit_email(
                                'ticket_by_unknown_user.eml',
                                :issue => {:project => 'onlinestore'},
                                :no_permission_check => '1',
                                :unknown_user => 'accept'
                              )
                      assert issue.is_a?(Issue)
                      assert issue.author.anonymous?
                      assert !issue.project.is_public?
                      assert_equal [issue.id, 1, 2], [issue.root_id, issue.lft, issue.rgt]
                    end
                  end
                end
                def test_add_issue_by_created_user
                  Setting.default_language = 'en'
                  assert_difference 'User.count' do
                    issue = submit_email(
                              'ticket_by_unknown_user.eml',
                              :issue => {:project => 'ecookbook'},
                              :unknown_user => 'create'
                            )
                    assert issue.is_a?(Issue)
                    assert issue.author.active?
                    assert_equal 'john.doe@somenet.foo', issue.author.mail
                    assert_equal 'John', issue.author.firstname
                    assert_equal 'Doe', issue.author.lastname
                    # account information
                    email = ActionMailer::Base.deliveries.first
                    assert_not_nil email
                    assert email.subject.include?('account activation')
                    login = mail_body(email).match(/\* Login: (.*)$/)[1].strip
                    password = mail_body(email).match(/\* Password: (.*)$/)[1].strip
                    assert_equal issue.author, User.try_to_login(login, password)
                  end
                end
                def test_add_issue_without_from_header
                  Role.anonymous.add_permission!(:add_issues)
                  assert_equal false, submit_email('ticket_without_from_header.eml')
                end
                def test_add_issue_with_invalid_attributes
                  issue = submit_email(
                            'ticket_with_invalid_attributes.eml',
                            :allow_override => 'tracker,category,priority'
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_nil issue.assigned_to
                  assert_nil issue.start_date
                  assert_nil issue.due_date
                  assert_equal 0, issue.done_ratio
                  assert_equal 'Normal', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_localized_attributes
                  User.find_by_mail('jsmith@somenet.foo').update_attribute 'language', 'fr'
                  issue = submit_email(
                            'ticket_with_localized_attributes.eml',
                            :allow_override => 'tracker,category,priority'
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'Feature request', issue.tracker.to_s
                  assert_equal 'Stock management', issue.category.to_s
                  assert_equal 'Urgent', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_japanese_keywords
                  ja_dev = "\xe9\x96\x8b\xe7\x99\xba"
                  ja_dev.force_encoding('UTF-8') if ja_dev.respond_to?(:force_encoding)
                  tracker = Tracker.create!(:name => ja_dev)
                  Project.find(1).trackers << tracker
                  issue = submit_email(
                            'japanese_keywords_iso_2022_jp.eml',
                            :issue => {:project => 'ecookbook'},
                            :allow_override => 'tracker'
                          )
                  assert_kind_of Issue, issue
                  assert_equal tracker, issue.tracker
                end
                def test_add_issue_from_apple_mail
                  issue = submit_email(
                            'apple_mail_with_attachment.eml',
                            :issue => {:project => 'ecookbook'}
                          )
                  assert_kind_of Issue, issue
                  assert_equal 1, issue.attachments.size
                  attachment = issue.attachments.first
                  assert_equal 'paella.jpg', attachment.filename
                  assert_equal 10790, attachment.filesize
                  assert File.exist?(attachment.diskfile)
                  assert_equal 10790, File.size(attachment.diskfile)
                  assert_equal 'caaf384198bcbc9563ab5c058acd73cd', attachment.digest
                end
                def test_thunderbird_with_attachment_ja
                  issue = submit_email(
                            'thunderbird_with_attachment_ja.eml',
                            :issue => {:project => 'ecookbook'}
                          )
                  assert_kind_of Issue, issue
                  assert_equal 1, issue.attachments.size
                  ja = "\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88.txt"
                  ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
                  attachment = issue.attachments.first
                  assert_equal ja, attachment.filename
                  assert_equal 5, attachment.filesize
                  assert File.exist?(attachment.diskfile)
                  assert_equal 5, File.size(attachment.diskfile)
                  assert_equal 'd8e8fca2dc0f896fd7cb4cb0031ba249', attachment.digest
                end
                def test_gmail_with_attachment_ja
                  issue = submit_email(
                            'gmail_with_attachment_ja.eml',
                            :issue => {:project => 'ecookbook'}
                          )
                  assert_kind_of Issue, issue
                  assert_equal 1, issue.attachments.size
                  ja = "\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88.txt"
                  ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
                  attachment = issue.attachments.first
                  assert_equal ja, attachment.filename
                  assert_equal 5, attachment.filesize
                  assert File.exist?(attachment.diskfile)
                  assert_equal 5, File.size(attachment.diskfile)
                  assert_equal 'd8e8fca2dc0f896fd7cb4cb0031ba249', attachment.digest
                end
                def test_thunderbird_with_attachment_latin1
                  issue = submit_email(
                            'thunderbird_with_attachment_iso-8859-1.eml',
                            :issue => {:project => 'ecookbook'}
                          )
                  assert_kind_of Issue, issue
                  assert_equal 1, issue.attachments.size
                  u = ""
                  u.force_encoding('UTF-8') if u.respond_to?(:force_encoding)
                  u1 = "\xc3\x84\xc3\xa4\xc3\x96\xc3\xb6\xc3\x9c\xc3\xbc"
                  u1.force_encoding('UTF-8') if u1.respond_to?(:force_encoding)
 .times { u << u1 }
                  attachment = issue.attachments.first
                  assert_equal "#{u}.png", attachment.filename
                  assert_equal 130, attachment.filesize
                  assert File.exist?(attachment.diskfile)
                  assert_equal 130, File.size(attachment.diskfile)
                  assert_equal '4d80e667ac37dddfe05502530f152abb', attachment.digest
                end
                def test_gmail_with_attachment_latin1
                  issue = submit_email(
                            'gmail_with_attachment_iso-8859-1.eml',
                            :issue => {:project => 'ecookbook'}
                          )
                  assert_kind_of Issue, issue
                  assert_equal 1, issue.attachments.size
                  u = ""
                  u.force_encoding('UTF-8') if u.respond_to?(:force_encoding)
                  u1 = "\xc3\x84\xc3\xa4\xc3\x96\xc3\xb6\xc3\x9c\xc3\xbc"
                  u1.force_encoding('UTF-8') if u1.respond_to?(:force_encoding)
 .times { u << u1 }
                  attachment = issue.attachments.first
                  assert_equal "#{u}.txt", attachment.filename
                  assert_equal 5, attachment.filesize
                  assert File.exist?(attachment.diskfile)
                  assert_equal 5, File.size(attachment.diskfile)
                  assert_equal 'd8e8fca2dc0f896fd7cb4cb0031ba249', attachment.digest
                end
                def test_add_issue_with_iso_8859_1_subject
                  issue = submit_email(
                            'subject_as_iso-8859-1.eml',
                            :issue => {:project => 'ecookbook'}
                          )
                  str = "Testmail from Webmail: \xc3\xa4 \xc3\xb6 \xc3\xbc..."
                  str.force_encoding('UTF-8') if str.respond_to?(:force_encoding)
                  assert_kind_of Issue, issue
                  assert_equal str, issue.subject
                end
                def test_add_issue_with_japanese_subject
                  issue = submit_email(
                            'subject_japanese_1.eml',
                            :issue => {:project => 'ecookbook'}
                          )
                  assert_kind_of Issue, issue
                  ja = "\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88"
                  ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
                  assert_equal ja, issue.subject
                end
                def test_add_issue_with_no_subject_header
                  issue = submit_email(
                            'no_subject_header.eml',
                            :issue => {:project => 'ecookbook'}
                          )
                  assert_kind_of Issue, issue
                  assert_equal '(no subject)', issue.subject
                end
                def test_add_issue_with_mixed_japanese_subject
                  issue = submit_email(
                            'subject_japanese_2.eml',
                            :issue => {:project => 'ecookbook'}
                          )
                  assert_kind_of Issue, issue
                  ja = "Re: \xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88"
                  ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
                  assert_equal ja, issue.subject
                end
                def test_should_ignore_emails_from_locked_users
                  User.find(2).lock!
                  MailHandler.any_instance.expects(:dispatch).never
                  assert_no_difference 'Issue.count' do
                    assert_equal false, submit_email('ticket_on_given_project.eml')
                  end
                end
                def test_should_ignore_emails_from_emission_address
                  Role.anonymous.add_permission!(:add_issues)
                  assert_no_difference 'User.count' do
                    assert_equal false,
                                 submit_email(
                                   'ticket_from_emission_address.eml',
                                   :issue => {:project => 'ecookbook'},
                                   :unknown_user => 'create'
                                 )
                  end
                end
                def test_should_ignore_auto_replied_emails
                  MailHandler.any_instance.expects(:dispatch).never
                  [
                    "X-Auto-Response-Suppress: OOF",
                    "Auto-Submitted: auto-replied",
                    "Auto-Submitted: Auto-Replied",
                    "Auto-Submitted: auto-generated"
                  ].each do |header|
                    raw = IO.read(File.join(FIXTURES_PATH, 'ticket_on_given_project.eml'))
                    raw = header + "\n" + raw
                    assert_no_difference 'Issue.count' do
                      assert_equal false, MailHandler.receive(raw), "email with #{header} header was not ignored"
                    end
                  end
                end
                def test_add_issue_should_send_email_notification
                  Setting.notified_events = ['issue_added']
                  ActionMailer::Base.deliveries.clear
                  # This email contains: 'Project: onlinestore'
                  issue = submit_email('ticket_on_given_project.eml')
                  assert issue.is_a?(Issue)
                  assert_equal 1, ActionMailer::Base.deliveries.size
                end
                def test_update_issue
                  journal = submit_email('ticket_reply.eml')
                  assert journal.is_a?(Journal)
                  assert_equal User.find_by_login('jsmith'), journal.user
                  assert_equal Issue.find(2), journal.journalized
                  assert_match /This is reply/, journal.notes
                  assert_equal false, journal.private_notes
                  assert_equal 'Feature request', journal.issue.tracker.name
                end
                def test_update_issue_with_attribute_changes
                  # This email contains: 'Status: Resolved'
                  journal = submit_email('ticket_reply_with_status.eml')
                  assert journal.is_a?(Journal)
                  issue = Issue.find(journal.issue.id)
                  assert_equal User.find_by_login('jsmith'), journal.user
                  assert_equal Issue.find(2), journal.journalized
                  assert_match /This is reply/, journal.notes
                  assert_equal 'Feature request', journal.issue.tracker.name
                  assert_equal IssueStatus.find_by_name("Resolved"), issue.status
                  assert_equal '2010-01-01', issue.start_date.to_s
                  assert_equal '2010-12-31', issue.due_date.to_s
                  assert_equal User.find_by_login('jsmith'), issue.assigned_to
                  assert_equal "52.6", issue.custom_value_for(CustomField.find_by_name('Float field')).value
                  # keywords should be removed from the email body
                  assert !journal.notes.match(/^Status:/i)
                  assert !journal.notes.match(/^Start Date:/i)
                end
                def test_update_issue_with_attachment
                  assert_difference 'Journal.count' do
                    assert_difference 'JournalDetail.count' do
                      assert_difference 'Attachment.count' do
                        assert_no_difference 'Issue.count' do
                          journal = submit_email('ticket_with_attachment.eml') do |raw|
                            raw.gsub! /^Subject: .*$/, 'Subject: Re: [Cookbook - Feature #2] (New) Add ingredients categories'
                          end
                        end
                      end
                    end
                  end
                  journal = Journal.first(:order => 'id DESC')
                  assert_equal Issue.find(2), journal.journalized
                  assert_equal 1, journal.details.size
                  detail = journal.details.first
                  assert_equal 'attachment', detail.property
                  assert_equal 'Paella.jpg', detail.value
                end
                def test_update_issue_should_send_email_notification
                  ActionMailer::Base.deliveries.clear
                  journal = submit_email('ticket_reply.eml')
                  assert journal.is_a?(Journal)
                  assert_equal 1, ActionMailer::Base.deliveries.size
                end
                def test_update_issue_should_not_set_defaults
                  journal = submit_email(
                              'ticket_reply.eml',
                              :issue => {:tracker => 'Support request', :priority => 'High'}
                            )
                  assert journal.is_a?(Journal)
                  assert_match /This is reply/, journal.notes
                  assert_equal 'Feature request', journal.issue.tracker.name
                  assert_equal 'Normal', journal.issue.priority.name
                end
                def test_replying_to_a_private_note_should_add_reply_as_private
                  private_journal = Journal.create!(:notes => 'Private notes', :journalized => Issue.find(1), :private_notes => true, :user_id => 2)
                  assert_difference 'Journal.count' do
                    journal = submit_email('ticket_reply.eml') do |email|
                      email.sub! %r{^In-Reply-To:.*$}, "In-Reply-To: <redmine.journal-#{private_journal.id}.20060719210421@osiris>"
                    end
                    assert_kind_of Journal, journal
                    assert_match /This is reply/, journal.notes
                    assert_equal true, journal.private_notes
                  end
                end
                def test_reply_to_a_message
                  m = submit_email('message_reply.eml')
                  assert m.is_a?(Message)
                  assert !m.new_record?
                  m.reload
                  assert_equal 'Reply via email', m.subject
                  # The email replies to message #2 which is part of the thread of message #1
                  assert_equal Message.find(1), m.parent
                end
                def test_reply_to_a_message_by_subject
                  m = submit_email('message_reply_by_subject.eml')
                  assert m.is_a?(Message)
                  assert !m.new_record?
                  m.reload
                  assert_equal 'Reply to the first post', m.subject
                  assert_equal Message.find(1), m.parent
                end
                def test_should_strip_tags_of_html_only_emails
                  issue = submit_email('ticket_html_only.eml', :issue => {:project => 'ecookbook'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'HTML email', issue.subject
                  assert_equal 'This is a html-only email.', issue.description
                end
-               context "truncate emails based on the Setting" do
-                 context "with no setting" do
-                   setup do
-                     Setting.mail_handler_body_delimiters = ''
-                   end
-                   should "add the entire email into the issue" do
-                     issue = submit_email('ticket_on_given_project.eml')
-                     assert_issue_created(issue)
-                     assert issue.description.include?('---')
-                     assert issue.description.include?('This paragraph is after the delimiter')
-                   end
+               test "truncate emails with no setting should add the entire email into the issue" do
+                 with_settings :mail_handler_body_delimiters => '' do
+                   issue = submit_email('ticket_on_given_project.eml')
+                   assert_issue_created(issue)
+                   assert issue.description.include?('---')
+                   assert issue.description.include?('This paragraph is after the delimiter')
                  end
+               end
-                 context "with a single string" do
-                   setup do
-                     Setting.mail_handler_body_delimiters = '---'
-                   end
-                   should "truncate the email at the delimiter for the issue" do
-                     issue = submit_email('ticket_on_given_project.eml')
-                     assert_issue_created(issue)
-                     assert issue.description.include?('This paragraph is before delimiters')
-                     assert issue.description.include?('--- This line starts with a delimiter')
-                     assert !issue.description.match(/^---$/)
-                     assert !issue.description.include?('This paragraph is after the delimiter')
-                   end
+               test "truncate emails with a single string should truncate the email at the delimiter for the issue" do
+                 with_settings :mail_handler_body_delimiters => '---' do
+                   issue = submit_email('ticket_on_given_project.eml')
+                   assert_issue_created(issue)
+                   assert issue.description.include?('This paragraph is before delimiters')
+                   assert issue.description.include?('--- This line starts with a delimiter')
+                   assert !issue.description.match(/^---$/)
+                   assert !issue.description.include?('This paragraph is after the delimiter')
                  end
+               end
-                 context "with a single quoted reply (e.g. reply to a Redmine email notification)" do
-                   setup do
-                     Setting.mail_handler_body_delimiters = '--- Reply above. Do not remove this line. ---'
-                   end
-                   should "truncate the email at the delimiter with the quoted reply symbols (>)" do
-                     journal = submit_email('issue_update_with_quoted_reply_above.eml')
-                     assert journal.is_a?(Journal)
-                     assert journal.notes.include?('An update to the issue by the sender.')
-                     assert !journal.notes.match(Regexp.escape("--- Reply above. Do not remove this line. ---"))
-                     assert !journal.notes.include?('Looks like the JSON api for projects was missed.')
-                   end
+               test "truncate emails with a single quoted reply should truncate the email at the delimiter with the quoted reply symbols (>)" do
+                 with_settings :mail_handler_body_delimiters => '--- Reply above. Do not remove this line. ---' do
+                   journal = submit_email('issue_update_with_quoted_reply_above.eml')
+                   assert journal.is_a?(Journal)
+                   assert journal.notes.include?('An update to the issue by the sender.')
+                   assert !journal.notes.match(Regexp.escape("--- Reply above. Do not remove this line. ---"))
+                   assert !journal.notes.include?('Looks like the JSON api for projects was missed.')
                  end
+               end
-                 context "with multiple quoted replies (e.g. reply to a reply of a Redmine email notification)" do
-                   setup do
-                     Setting.mail_handler_body_delimiters = '--- Reply above. Do not remove this line. ---'
-                   end
-                   should "truncate the email at the delimiter with the quoted reply symbols (>)" do
-                     journal = submit_email('issue_update_with_multiple_quoted_reply_above.eml')
-                     assert journal.is_a?(Journal)
-                     assert journal.notes.include?('An update to the issue by the sender.')
-                     assert !journal.notes.match(Regexp.escape("--- Reply above. Do not remove this line. ---"))
-                     assert !journal.notes.include?('Looks like the JSON api for projects was missed.')
-                   end
+               test "truncate emails with multiple quoted replies should truncate the email at the delimiter with the quoted reply symbols (>)" do
+                 with_settings :mail_handler_body_delimiters => '--- Reply above. Do not remove this line. ---' do
+                   journal = submit_email('issue_update_with_multiple_quoted_reply_above.eml')
+                   assert journal.is_a?(Journal)
+                   assert journal.notes.include?('An update to the issue by the sender.')
+                   assert !journal.notes.match(Regexp.escape("--- Reply above. Do not remove this line. ---"))
+                   assert !journal.notes.include?('Looks like the JSON api for projects was missed.')
                  end
+               end
-                 context "with multiple strings" do
-                   setup do
-                     Setting.mail_handler_body_delimiters = "---\nBREAK"
-                   end
-                   should "truncate the email at the first delimiter found (BREAK)" do
-                     issue = submit_email('ticket_on_given_project.eml')
-                     assert_issue_created(issue)
-                     assert issue.description.include?('This paragraph is before delimiters')
-                     assert !issue.description.include?('BREAK')
-                     assert !issue.description.include?('This paragraph is between delimiters')
-                     assert !issue.description.match(/^---$/)
-                     assert !issue.description.include?('This paragraph is after the delimiter')
-                   end
+               test "truncate emails with multiple strings should truncate the email at the first delimiter found (BREAK)" do
+                 with_settings :mail_handler_body_delimiters => "---\nBREAK" do
+                   issue = submit_email('ticket_on_given_project.eml')
+                   assert_issue_created(issue)
+                   assert issue.description.include?('This paragraph is before delimiters')
+                   assert !issue.description.include?('BREAK')
+                   assert !issue.description.include?('This paragraph is between delimiters')
+                   assert !issue.description.match(/^---$/)
+                   assert !issue.description.include?('This paragraph is after the delimiter')
                  end
                end
                def test_email_with_long_subject_line
                  issue = submit_email('ticket_with_long_subject.eml')
                  assert issue.is_a?(Issue)
                  assert_equal issue.subject, 'New ticket on a given project with a very long subject line which exceeds 255 chars and should not be ignored but chopped off. And if the subject line is still not long enough, we just add more text. And more text. Wow, this is really annoying. Especially, if you have nothing to say...'[0,255]
                end
                def test_new_user_from_attributes_should_return_valid_user
                  to_test = {
                    # [address, name] => [login, firstname, lastname]
                    ['jsmith@example.net', nil] => ['jsmith@example.net', 'jsmith', '-'],
                    ['jsmith@example.net', 'John'] => ['jsmith@example.net', 'John', '-'],
                    ['jsmith@example.net', 'John Smith'] => ['jsmith@example.net', 'John', 'Smith'],
                    ['jsmith@example.net', 'John Paul Smith'] => ['jsmith@example.net', 'John', 'Paul Smith'],
                    ['jsmith@example.net', 'AVeryLongFirstnameThatExceedsTheMaximumLength Smith'] => ['jsmith@example.net', 'AVeryLongFirstnameThatExceedsT', 'Smith'],
                    ['jsmith@example.net', 'John AVeryLongLastnameThatExceedsTheMaximumLength'] => ['jsmith@example.net', 'John', 'AVeryLongLastnameThatExceedsTh']
                  }
                  to_test.each do |attrs, expected|
                    user = MailHandler.new_user_from_attributes(attrs.first, attrs.last)
                    assert user.valid?, user.errors.full_messages.to_s
                    assert_equal attrs.first, user.mail
                    assert_equal expected[0], user.login
                    assert_equal expected[1], user.firstname
                    assert_equal expected[2], user.lastname
                  end
                end
                def test_new_user_from_attributes_should_respect_minimum_password_length
                  with_settings :password_min_length => 15 do
                    user = MailHandler.new_user_from_attributes('jsmith@example.net')
                    assert user.valid?
                    assert user.password.length >= 15
                  end
                end
                def test_new_user_from_attributes_should_use_default_login_if_invalid
                  user = MailHandler.new_user_from_attributes('foo+bar@example.net')
                  assert user.valid?
                  assert user.login =~ /^user[a-f0-9]+$/
                  assert_equal 'foo+bar@example.net', user.mail
                end
                def test_new_user_with_utf8_encoded_fullname_should_be_decoded
                  assert_difference 'User.count' do
                    issue = submit_email(
                              'fullname_of_sender_as_utf8_encoded.eml',
                              :issue => {:project => 'ecookbook'},
                              :unknown_user => 'create'
                            )
                  end
                  user = User.first(:order => 'id DESC')
                  assert_equal "foo@example.org", user.mail
                  str1 = "\xc3\x84\xc3\xa4"
                  str2 = "\xc3\x96\xc3\xb6"
                  str1.force_encoding('UTF-8') if str1.respond_to?(:force_encoding)
                  str2.force_encoding('UTF-8') if str2.respond_to?(:force_encoding)
                  assert_equal str1, user.firstname
                  assert_equal str2, user.lastname
                end
                private
                def submit_email(filename, options={})
                  raw = IO.read(File.join(FIXTURES_PATH, filename))
                  yield raw if block_given?
                  MailHandler.receive(raw, options)
                end
                def assert_issue_created(issue)
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                end
              end

test/unit/mailer_test.rb +30 -34

              # Redmine - project management software
              # Copyright (C) 2006-2013  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__)
              class MailerTest < ActiveSupport::TestCase
                include Redmine::I18n
                include ActionDispatch::Assertions::SelectorAssertions
                fixtures :projects, :enabled_modules, :issues, :users, :members,
                         :member_roles, :roles, :documents, :attachments, :news,
                         :tokens, :journals, :journal_details, :changesets,
                         :trackers, :projects_trackers,
                         :issue_statuses, :enumerations, :messages, :boards, :repositories,
                         :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,
                         :versions,
                         :comments
                def setup
                  ActionMailer::Base.deliveries.clear
                  Setting.host_name = 'mydomain.foo'
                  Setting.protocol = 'http'
                  Setting.plain_text_mail = '0'
                end
                def test_generated_links_in_emails
                  Setting.default_language = 'en'
                  Setting.host_name = 'mydomain.foo'
                  Setting.protocol = 'https'
                  journal = Journal.find(3)
                  assert Mailer.issue_edit(journal).deliver
                  mail = last_email
                  assert_not_nil mail
                  assert_select_email do
                    # link to the main ticket
                    assert_select 'a[href=?]',
                                  'https://mydomain.foo/issues/2#change-3',
                                  :text => 'Feature request #2: Add ingredients categories'
                    # link to a referenced ticket
                    assert_select 'a[href=?][title=?]',
                                  'https://mydomain.foo/issues/1',
                                  'Can&#x27;t print recipes (New)',
                                  :text => '#1'
                    # link to a changeset
                    assert_select 'a[href=?][title=?]',
                                  'https://mydomain.foo/projects/ecookbook/repository/revisions/2',
                                  'This commit fixes #1, #2 and references #1 &amp; #3',
                                  :text => 'r2'
                    # link to a description diff
                    assert_select 'a[href=?][title=?]',
                                  'https://mydomain.foo/journals/diff/3?detail_id=4',
                                  'View differences',
                                  :text => 'diff'
                    # link to an attachment
                    assert_select 'a[href=?]',
                                  'https://mydomain.foo/attachments/download/4/source.rb',
                                  :text => 'source.rb'
                  end
                end
                def test_generated_links_with_prefix
                  Setting.default_language = 'en'
                  relative_url_root = Redmine::Utils.relative_url_root
                  Setting.host_name = 'mydomain.foo/rdm'
                  Setting.protocol = 'http'
                  journal = Journal.find(3)
                  assert Mailer.issue_edit(journal).deliver
                  mail = last_email
                  assert_not_nil mail
                  assert_select_email do
                    # link to the main ticket
                    assert_select 'a[href=?]',
                                  'http://mydomain.foo/rdm/issues/2#change-3',
                                  :text => 'Feature request #2: Add ingredients categories'
                    # link to a referenced ticket
                    assert_select 'a[href=?][title=?]',
                                  'http://mydomain.foo/rdm/issues/1',
                                  'Can&#x27;t print recipes (New)',
                                  :text => '#1'
                    # link to a changeset
                    assert_select 'a[href=?][title=?]',
                                  'http://mydomain.foo/rdm/projects/ecookbook/repository/revisions/2',
                                  'This commit fixes #1, #2 and references #1 &amp; #3',
                                  :text => 'r2'
                    # link to a description diff
                    assert_select 'a[href=?][title=?]',
                                  'http://mydomain.foo/rdm/journals/diff/3?detail_id=4',
                                  'View differences',
                                  :text => 'diff'
                    # link to an attachment
                    assert_select 'a[href=?]',
                                  'http://mydomain.foo/rdm/attachments/download/4/source.rb',
                                  :text => 'source.rb'
                  end
                end
                def test_generated_links_with_prefix_and_no_relative_url_root
                  Setting.default_language = 'en'
                  relative_url_root = Redmine::Utils.relative_url_root
                  Setting.host_name = 'mydomain.foo/rdm'
                  Setting.protocol = 'http'
                  Redmine::Utils.relative_url_root = nil
                  journal = Journal.find(3)
                  assert Mailer.issue_edit(journal).deliver
                  mail = last_email
                  assert_not_nil mail
                  assert_select_email do
                    # link to the main ticket
                    assert_select 'a[href=?]',
                                  'http://mydomain.foo/rdm/issues/2#change-3',
                                  :text => 'Feature request #2: Add ingredients categories'
                    # link to a referenced ticket
                    assert_select 'a[href=?][title=?]',
                                  'http://mydomain.foo/rdm/issues/1',
                                  'Can&#x27;t print recipes (New)',
                                  :text => '#1'
                    # link to a changeset
                    assert_select 'a[href=?][title=?]',
                                  'http://mydomain.foo/rdm/projects/ecookbook/repository/revisions/2',
                                  'This commit fixes #1, #2 and references #1 &amp; #3',
                                  :text => 'r2'
                    # link to a description diff
                    assert_select 'a[href=?][title=?]',
                                  'http://mydomain.foo/rdm/journals/diff/3?detail_id=4',
                                  'View differences',
                                  :text => 'diff'
                    # link to an attachment
                    assert_select 'a[href=?]',
                                  'http://mydomain.foo/rdm/attachments/download/4/source.rb',
                                  :text => 'source.rb'
                  end
                ensure
                  # restore it
                  Redmine::Utils.relative_url_root = relative_url_root
                end
                def test_email_headers
                  issue = Issue.find(1)
                  Mailer.issue_add(issue).deliver
                  mail = last_email
                  assert_not_nil mail
                  assert_equal 'OOF', mail.header['X-Auto-Response-Suppress'].to_s
                  assert_equal 'auto-generated', mail.header['Auto-Submitted'].to_s
                  assert_equal '<redmine.example.net>', mail.header['List-Id'].to_s
                end
                def test_email_headers_should_include_sender
                  issue = Issue.find(1)
                  Mailer.issue_add(issue).deliver
                  mail = last_email
                  assert_equal issue.author.login, mail.header['X-Redmine-Sender'].to_s
                end
                def test_plain_text_mail
                  Setting.plain_text_mail = 1
                  journal = Journal.find(2)
                  Mailer.issue_edit(journal).deliver
                  mail = last_email
                  assert_equal "text/plain; charset=UTF-8", mail.content_type
                  assert_equal 0, mail.parts.size
                  assert !mail.encoded.include?('href')
                end
                def test_html_mail
                  Setting.plain_text_mail = 0
                  journal = Journal.find(2)
                  Mailer.issue_edit(journal).deliver
                  mail = last_email
                  assert_equal 2, mail.parts.size
                  assert mail.encoded.include?('href')
                end
                def test_from_header
                  with_settings :mail_from => 'redmine@example.net' do
                    Mailer.test_email(User.find(1)).deliver
                  end
                  mail = last_email
                  assert_equal 'redmine@example.net', mail.from_addrs.first
                end
                def test_from_header_with_phrase
                  with_settings :mail_from => 'Redmine app <redmine@example.net>' do
                    Mailer.test_email(User.find(1)).deliver
                  end
                  mail = last_email
                  assert_equal 'redmine@example.net', mail.from_addrs.first
                  assert_equal 'Redmine app <redmine@example.net>', mail.header['From'].to_s
                end
                def test_should_not_send_email_without_recipient
                  news = News.first
                  user = news.author
                  # Remove members except news author
                  news.project.memberships.each {|m| m.destroy unless m.user == user}
                  user.pref[:no_self_notified] = false
                  user.pref.save
                  User.current = user
                  Mailer.news_added(news.reload).deliver
                  assert_equal 1, last_email.bcc.size
                  # nobody to notify
                  user.pref[:no_self_notified] = true
                  user.pref.save
                  User.current = user
                  ActionMailer::Base.deliveries.clear
                  Mailer.news_added(news.reload).deliver
                  assert ActionMailer::Base.deliveries.empty?
                end
                def test_issue_add_message_id
                  issue = Issue.find(1)
                  Mailer.issue_add(issue).deliver
                  mail = last_email
                  assert_equal Mailer.message_id_for(issue), mail.message_id
                  assert_nil mail.references
                end
                def test_issue_edit_message_id
                  journal = Journal.find(1)
                  Mailer.issue_edit(journal).deliver
                  mail = last_email
                  assert_equal Mailer.message_id_for(journal), mail.message_id
                  assert_include Mailer.message_id_for(journal.issue), mail.references
                  assert_select_email do
                    # link to the update
                    assert_select "a[href=?]",
                                  "http://mydomain.foo/issues/#{journal.journalized_id}#change-#{journal.id}"
                  end
                end
                def test_message_posted_message_id
                  message = Message.find(1)
                  Mailer.message_posted(message).deliver
                  mail = last_email
                  assert_equal Mailer.message_id_for(message), mail.message_id
                  assert_nil mail.references
                  assert_select_email do
                    # link to the message
                    assert_select "a[href=?]",
                                  "http://mydomain.foo/boards/#{message.board.id}/topics/#{message.id}",
                                  :text => message.subject
                  end
                end
                def test_reply_posted_message_id
                  message = Message.find(3)
                  Mailer.message_posted(message).deliver
                  mail = last_email
                  assert_equal Mailer.message_id_for(message), mail.message_id
                  assert_include Mailer.message_id_for(message.parent), mail.references
                  assert_select_email do
                    # link to the reply
                    assert_select "a[href=?]",
                                  "http://mydomain.foo/boards/#{message.board.id}/topics/#{message.root.id}?r=#{message.id}#message-#{message.id}",
                                  :text => message.subject
                  end
                end
-               context("#issue_add") do
-                 setup do
-                   ActionMailer::Base.deliveries.clear
-                   Setting.bcc_recipients = '1'
-                   @issue = Issue.find(1)
-                 end
+               test "#issue_add should notify project members" do
+                 issue = Issue.find(1)
+                 assert Mailer.issue_add(issue).deliver
+                 assert last_email.bcc.include?('dlopper@somenet.foo')
+               end
-                 should "notify project members" do
-                   assert Mailer.issue_add(@issue).deliver
-                   assert last_email.bcc.include?('dlopper@somenet.foo')
-                 end
+               test "#issue_add should not notify project members that are not allow to view the issue" do
+                 issue = Issue.find(1)
+                 Role.find(2).remove_permission!(:view_issues)
+                 assert Mailer.issue_add(issue).deliver
+                 assert !last_email.bcc.include?('dlopper@somenet.foo')
+               end
-                 should "not notify project members that are not allow to view the issue" do
-                   Role.find(2).remove_permission!(:view_issues)
-                   assert Mailer.issue_add(@issue).deliver
-                   assert !last_email.bcc.include?('dlopper@somenet.foo')
-                 end
+               test "#issue_add should notify issue watchers" do
+                 issue = Issue.find(1)
+                 user = User.find(9)
+                 # minimal email notification options
+                 user.pref[:no_self_notified] = '1'
+                 user.pref.save
+                 user.mail_notification = false
+                 user.save
-                 should "notify issue watchers" do
-                   user = User.find(9)
-                   # minimal email notification options
-                   user.pref[:no_self_notified] = '1'
-                   user.pref.save
-                   user.mail_notification = false
-                   user.save
-                   Watcher.create!(:watchable => @issue, :user => user)
-                   assert Mailer.issue_add(@issue).deliver
-                   assert last_email.bcc.include?(user.mail)
-                 end
+                 Watcher.create!(:watchable => issue, :user => user)
+                 assert Mailer.issue_add(issue).deliver
+                 assert last_email.bcc.include?(user.mail)
+               end
-                 should "not notify watchers not allowed to view the issue" do
-                   user = User.find(9)
-                   Watcher.create!(:watchable => @issue, :user => user)
-                   Role.non_member.remove_permission!(:view_issues)
-                   assert Mailer.issue_add(@issue).deliver
-                   assert !last_email.bcc.include?(user.mail)
-                 end
+               test "#issue_add should not notify watchers not allowed to view the issue" do
+                 issue = Issue.find(1)
+                 user = User.find(9)
+                 Watcher.create!(:watchable => issue, :user => user)
+                 Role.non_member.remove_permission!(:view_issues)
+                 assert Mailer.issue_add(issue).deliver
+                 assert !last_email.bcc.include?(user.mail)
                end
                # test mailer methods for each language
                def test_issue_add
                  issue = Issue.find(1)
                  valid_languages.each do |lang|
                    Setting.default_language = lang.to_s
                    assert Mailer.issue_add(issue).deliver
                  end
                end
                def test_issue_edit
                  journal = Journal.find(1)
                  valid_languages.each do |lang|
                    Setting.default_language = lang.to_s
                    assert Mailer.issue_edit(journal).deliver
                  end
                end
                def test_issue_edit_should_send_private_notes_to_users_with_permission_only
                  journal = Journal.find(1)
                  journal.private_notes = true
                  journal.save!
                  Role.find(2).add_permission! :view_private_notes
                  Mailer.issue_edit(journal).deliver
                  assert_equal %w(dlopper@somenet.foo jsmith@somenet.foo), ActionMailer::Base.deliveries.last.bcc.sort
                  Role.find(2).remove_permission! :view_private_notes
                  Mailer.issue_edit(journal).deliver
                  assert_equal %w(jsmith@somenet.foo), ActionMailer::Base.deliveries.last.bcc.sort
                end
                def test_issue_edit_should_send_private_notes_to_watchers_with_permission_only
                  Issue.find(1).set_watcher(User.find_by_login('someone'))
                  journal = Journal.find(1)
                  journal.private_notes = true
                  journal.save!
                  Role.non_member.add_permission! :view_private_notes
                  Mailer.issue_edit(journal).deliver
                  assert_include 'someone@foo.bar', ActionMailer::Base.deliveries.last.bcc.sort
                  Role.non_member.remove_permission! :view_private_notes
                  Mailer.issue_edit(journal).deliver
                  assert_not_include 'someone@foo.bar', ActionMailer::Base.deliveries.last.bcc.sort
                end
                def test_document_added
                  document = Document.find(1)
                  valid_languages.each do |lang|
                    Setting.default_language = lang.to_s
                    assert Mailer.document_added(document).deliver
                  end
                end
                def test_attachments_added
                  attachements = [ Attachment.find_by_container_type('Document') ]
                  valid_languages.each do |lang|
                    Setting.default_language = lang.to_s
                    assert Mailer.attachments_added(attachements).deliver
                  end
                end
                def test_version_file_added
                  attachements = [ Attachment.find_by_container_type('Version') ]
                  assert Mailer.attachments_added(attachements).deliver
                  assert_not_nil last_email.bcc
                  assert last_email.bcc.any?
                  assert_select_email do
                    assert_select "a[href=?]", "http://mydomain.foo/projects/ecookbook/files"
                  end
                end
                def test_project_file_added
                  attachements = [ Attachment.find_by_container_type('Project') ]
                  assert Mailer.attachments_added(attachements).deliver
                  assert_not_nil last_email.bcc
                  assert last_email.bcc.any?
                  assert_select_email do
                    assert_select "a[href=?]", "http://mydomain.foo/projects/ecookbook/files"
                  end
                end
                def test_news_added
                  news = News.first
                  valid_languages.each do |lang|
                    Setting.default_language = lang.to_s
                    assert Mailer.news_added(news).deliver
                  end
                end
                def test_news_comment_added
                  comment = Comment.find(2)
                  valid_languages.each do |lang|
                    Setting.default_language = lang.to_s
                    assert Mailer.news_comment_added(comment).deliver
                  end
                end
                def test_message_posted
                  message = Message.first
                  recipients = ([message.root] + message.root.children).collect {|m| m.author.mail if m.author}
                  recipients = recipients.compact.uniq
                  valid_languages.each do |lang|
                    Setting.default_language = lang.to_s
                    assert Mailer.message_posted(message).deliver
                  end
                end
                def test_wiki_content_added
                  content = WikiContent.find(1)
                  valid_languages.each do |lang|
                    Setting.default_language = lang.to_s
                    assert_difference 'ActionMailer::Base.deliveries.size' do
                      assert Mailer.wiki_content_added(content).deliver
                      assert_select_email do
                        assert_select 'a[href=?]',
                          'http://mydomain.foo/projects/ecookbook/wiki/CookBook_documentation',
                          :text => 'CookBook documentation'
                      end
                    end
                  end
                end
                def test_wiki_content_updated
                  content = WikiContent.find(1)
                  valid_languages.each do |lang|
                    Setting.default_language = lang.to_s
                    assert_difference 'ActionMailer::Base.deliveries.size' do
                      assert Mailer.wiki_content_updated(content).deliver
                      assert_select_email do
                        assert_select 'a[href=?]',
                          'http://mydomain.foo/projects/ecookbook/wiki/CookBook_documentation',
                          :text => 'CookBook documentation'
                      end
                    end
                  end
                end
                def test_account_information
                  user = User.find(2)
                  valid_languages.each do |lang|
                    user.update_attribute :language, lang.to_s
                    user.reload
                    assert Mailer.account_information(user, 'pAsswORd').deliver
                  end
                end
                def test_lost_password
                  token = Token.find(2)
                  valid_languages.each do |lang|
                    token.user.update_attribute :language, lang.to_s
                    token.reload
                    assert Mailer.lost_password(token).deliver
                  end
                end
                def test_register
                  token = Token.find(1)
                  Setting.host_name = 'redmine.foo'
                  Setting.protocol = 'https'
                  valid_languages.each do |lang|
                    token.user.update_attribute :language, lang.to_s
                    token.reload
                    ActionMailer::Base.deliveries.clear
                    assert Mailer.register(token).deliver
                    mail = last_email
                    assert_select_email do
                      assert_select "a[href=?]",
                                    "https://redmine.foo/account/activate?token=#{token.value}",
                                    :text => "https://redmine.foo/account/activate?token=#{token.value}"
                    end
                  end
                end
                def test_test
                  user = User.find(1)
                  valid_languages.each do |lang|
                    user.update_attribute :language, lang.to_s
                    assert Mailer.test_email(user).deliver
                  end
                end
                def test_reminders
                  Mailer.reminders(:days => 42)
                  assert_equal 1, ActionMailer::Base.deliveries.size
                  mail = last_email
                  assert mail.bcc.include?('dlopper@somenet.foo')
                  assert_mail_body_match 'Bug #3: Error 281 when updating a recipe', mail
                  assert_equal '1 issue(s) due in the next 42 days', mail.subject
                end
                def test_reminders_should_not_include_closed_issues
                  with_settings :default_language => 'en' do
                    Issue.create!(:project_id => 1, :tracker_id => 1, :status_id => 5,
                                    :subject => 'Closed issue', :assigned_to_id => 3,
                                    :due_date => 5.days.from_now,
                                    :author_id => 2)
                    ActionMailer::Base.deliveries.clear
                    Mailer.reminders(:days => 42)
                    assert_equal 1, ActionMailer::Base.deliveries.size
                    mail = last_email
                    assert mail.bcc.include?('dlopper@somenet.foo')
                    assert_mail_body_no_match 'Closed issue', mail
                  end
                end
                def test_reminders_for_users
                  Mailer.reminders(:days => 42, :users => ['5'])
                  assert_equal 0, ActionMailer::Base.deliveries.size # No mail for dlopper
                  Mailer.reminders(:days => 42, :users => ['3'])
                  assert_equal 1, ActionMailer::Base.deliveries.size # No mail for dlopper
                  mail = last_email
                  assert mail.bcc.include?('dlopper@somenet.foo')
                  assert_mail_body_match 'Bug #3: Error 281 when updating a recipe', mail
                end
                def test_reminder_should_include_issues_assigned_to_groups
                  with_settings :default_language => 'en' do
                    group = Group.generate!
                    group.users << User.find(2)
                    group.users << User.find(3)
                    Issue.create!(:project_id => 1, :tracker_id => 1, :status_id => 1,
                                    :subject => 'Assigned to group', :assigned_to => group,
                                    :due_date => 5.days.from_now,
                                    :author_id => 2)
                    ActionMailer::Base.deliveries.clear
                    Mailer.reminders(:days => 7)
                    assert_equal 2, ActionMailer::Base.deliveries.size
                    assert_equal %w(dlopper@somenet.foo jsmith@somenet.foo), ActionMailer::Base.deliveries.map(&:bcc).flatten.sort
                    ActionMailer::Base.deliveries.each do |mail|
                      assert_mail_body_match 'Assigned to group', mail
                    end
                  end
                end
                def test_mailer_should_not_change_locale
                  Setting.default_language = 'en'
                  # Set current language to italian
                  set_language_if_valid 'it'
                  # Send an email to a french user
                  user = User.find(1)
                  user.language = 'fr'
                  Mailer.account_activated(user).deliver
                  mail = last_email
                  assert_mail_body_match 'Votre compte', mail
                  assert_equal :it, current_language
                end
                def test_with_deliveries_off
                  Mailer.with_deliveries false do
                    Mailer.test_email(User.find(1)).deliver
                  end
                  assert ActionMailer::Base.deliveries.empty?
                  # should restore perform_deliveries
                  assert ActionMailer::Base.perform_deliveries
                end
                def test_layout_should_include_the_emails_header
                  with_settings :emails_header => "*Header content*" do
                    assert Mailer.test_email(User.find(1)).deliver
                    assert_select_email do
                      assert_select ".header" do
                        assert_select "strong", :text => "Header content"
                      end
                    end
                  end
                end
                def test_should_escape_html_templates_only
                  Issue.generate!(:project_id => 1, :tracker_id => 1, :subject => 'Subject with a <tag>')
                  mail = last_email
                  assert_equal 2, mail.parts.size
                  assert_include '<tag>', text_part.body.encoded
                  assert_include '&lt;tag&gt;', html_part.body.encoded
                end
                private
                def last_email
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  mail
                end
                def text_part
                  last_email.parts.detect {|part| part.content_type.include?('text/plain')}
                end
                def html_part
                  last_email.parts.detect {|part| part.content_type.include?('text/html')}
                end
              end

test/unit/principal_test.rb +29 -47

              # encoding: utf-8
              #
              # Redmine - project management software
              # Copyright (C) 2006-2013  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__)
              class PrincipalTest < ActiveSupport::TestCase
                fixtures :users, :projects, :members, :member_roles
                def test_active_scope_should_return_groups_and_active_users
                  result = Principal.active.all
                  assert_include Group.first, result
                  assert_not_nil result.detect {|p| p.is_a?(User)}
                  assert_nil result.detect {|p| p.is_a?(User) && !p.active?}
                  assert_nil result.detect {|p| p.is_a?(AnonymousUser)}
                end
                def test_member_of_scope_should_return_the_union_of_all_members
                  projects = Project.find_all_by_id(1, 2)
                  assert_equal projects.map(&:principals).flatten.sort, Principal.member_of(projects).sort
                end
                def test_member_of_scope_should_be_empty_for_no_projects
                  assert_equal [], Principal.member_of([]).sort
                end
                def test_not_member_of_scope_should_return_users_that_have_no_memberships
                  projects = Project.find_all_by_id(1, 2)
                  expected = (Principal.all - projects.map(&:memberships).flatten.map(&:principal)).sort
                  assert_equal expected, Principal.not_member_of(projects).sort
                end
                def test_not_member_of_scope_should_be_empty_for_no_projects
                  assert_equal [], Principal.not_member_of([]).sort
                end
                def test_sorted_scope_should_sort_users_before_groups
                  scope = Principal.where("type <> ?", 'AnonymousUser')
                  expected_order = scope.all.sort do |a, b|
                    if a.is_a?(User) && b.is_a?(Group)
                      -1
                    elsif a.is_a?(Group) && b.is_a?(User)
 
                    else
                      a.name.downcase <=> b.name.downcase
                    end
                  end
                  assert_equal expected_order.map(&:name).map(&:downcase), scope.sorted.all.map(&:name).map(&:downcase)
                end
-               context "#like" do
-                 setup do
-                   Principal.create!(:login => 'login')
-                   Principal.create!(:login => 'login2')
+               test "like scope should search login" do
+                 results = Principal.like('jsmi')
-                   Principal.create!(:firstname => 'firstname')
-                   Principal.create!(:firstname => 'firstname2')
-                   Principal.create!(:lastname => 'lastname')
-                   Principal.create!(:lastname => 'lastname2')
-                   Principal.create!(:mail => 'mail@example.com')
-                   Principal.create!(:mail => 'mail2@example.com')
-                   @palmer = Principal.create!(:firstname => 'David', :lastname => 'Palmer')
-                 end
-                 should "search login" do
-                   results = Principal.like('login')
-                   assert_equal 2, results.count
-                   assert results.all? {|u| u.login.match(/login/) }
-                 end
+                 assert results.any?
+                 assert results.all? {|u| u.login.match(/jsmi/i) }
+               end
-                 should "search firstname" do
-                   results = Principal.like('firstname')
+               test "like scope should search firstname" do
+                 results = Principal.like('john')
-                   assert_equal 2, results.count
-                   assert results.all? {|u| u.firstname.match(/firstname/) }
-                 end
+                 assert results.any?
+                 assert results.all? {|u| u.firstname.match(/john/i) }
+               end
-                 should "search lastname" do
-                   results = Principal.like('lastname')
+               test "like scope should search lastname" do
+                 results = Principal.like('smi')
-                   assert_equal 2, results.count
-                   assert results.all? {|u| u.lastname.match(/lastname/) }
-                 end
+                 assert results.any?
+                 assert results.all? {|u| u.lastname.match(/smi/i) }
+               end
-                 should "search mail" do
-                   results = Principal.like('mail')
+               test "like scope should search mail" do
+                 results = Principal.like('somenet')
-                   assert_equal 2, results.count
-                   assert results.all? {|u| u.mail.match(/mail/) }
-                 end
+                 assert results.any?
+                 assert results.all? {|u| u.mail.match(/somenet/i) }
+               end
-                 should "search firstname and lastname" do
-                   results = Principal.like('david palm')
+               test "like scope should search firstname and lastname" do
+                 results = Principal.like('john smi')
-                   assert_equal 1, results.count
-                   assert_equal @palmer, results.first
-                 end
+                 assert_equal 1, results.count
+                 assert_equal User.find(2), results.first
+               end
-                 should "search lastname and firstname" do
-                   results = Principal.like('palmer davi')
+               test "like scope should search lastname and firstname" do
+                 results = Principal.like('smith joh')
-                   assert_equal 1, results.count
-                   assert_equal @palmer, results.first
-                 end
+                 assert_equal 1, results.count
+                 assert_equal User.find(2), results.first
                end
                def test_like_scope_with_cyrillic_name
                  user = User.generate!(:firstname => 'Соболев', :lastname => 'Денис')
                  results = Principal.like('Собо')
                  assert_equal 1, results.count
                  assert_equal user, results.first
                end
              end

test/unit/project_test.rb +87 -92

              # Redmine - project management software
              # Copyright (C) 2006-2013  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__)
              class ProjectTest < ActiveSupport::TestCase
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :journals, :journal_details,
                         :enumerations, :users, :issue_categories,
                         :projects_trackers,
                         :custom_fields,
                         :custom_fields_projects,
                         :custom_fields_trackers,
                         :custom_values,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules,
                         :workflows,
                         :versions,
                         :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,
                         :groups_users,
                         :boards, :messages,
                         :repositories,
                         :news, :comments,
                         :documents
                def setup
                  @ecookbook = Project.find(1)
                  @ecookbook_sub1 = Project.find(3)
                  set_tmp_attachments_directory
                  User.current = nil
                end
                def test_truth
                  assert_kind_of Project, @ecookbook
                  assert_equal "eCookbook", @ecookbook.name
                end
                def test_default_attributes
                  with_settings :default_projects_public => '1' do
                    assert_equal true, Project.new.is_public
                    assert_equal false, Project.new(:is_public => false).is_public
                  end
                  with_settings :default_projects_public => '0' do
                    assert_equal false, Project.new.is_public
                    assert_equal true, Project.new(:is_public => true).is_public
                  end
                  with_settings :sequential_project_identifiers => '1' do
                    assert !Project.new.identifier.blank?
                    assert Project.new(:identifier => '').identifier.blank?
                  end
                  with_settings :sequential_project_identifiers => '0' do
                    assert Project.new.identifier.blank?
                    assert !Project.new(:identifier => 'test').blank?
                  end
                  with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
                    assert_equal ['issue_tracking', 'repository'], Project.new.enabled_module_names
                  end
                  assert_equal Tracker.all.sort, Project.new.trackers.sort
                  assert_equal Tracker.find(1, 3).sort, Project.new(:tracker_ids => [1, 3]).trackers.sort
                end
                def test_update
                  assert_equal "eCookbook", @ecookbook.name
                  @ecookbook.name = "eCook"
                  assert @ecookbook.save, @ecookbook.errors.full_messages.join("; ")
                  @ecookbook.reload
                  assert_equal "eCook", @ecookbook.name
                end
                def test_validate_identifier
                  to_test = {"abc" => true,
                             "ab12" => true,
                             "ab-12" => true,
                             "ab_12" => true,
                             "12" => false,
                             "new" => false}
                  to_test.each do |identifier, valid|
                    p = Project.new
                    p.identifier = identifier
                    p.valid?
                    if valid
                      assert p.errors['identifier'].blank?, "identifier #{identifier} was not valid"
                    else
                      assert p.errors['identifier'].present?, "identifier #{identifier} was valid"
                    end
                  end
                end
                def test_identifier_should_not_be_frozen_for_a_new_project
                  assert_equal false, Project.new.identifier_frozen?
                end
                def test_identifier_should_not_be_frozen_for_a_saved_project_with_blank_identifier
                  Project.update_all(["identifier = ''"], "id = 1")
                  assert_equal false, Project.find(1).identifier_frozen?
                end
                def test_identifier_should_be_frozen_for_a_saved_project_with_valid_identifier
                  assert_equal true, Project.find(1).identifier_frozen?
                end
                def test_members_should_be_active_users
                  Project.all.each do |project|
                    assert_nil project.members.detect {|m| !(m.user.is_a?(User) && m.user.active?) }
                  end
                end
                def test_users_should_be_active_users
                  Project.all.each do |project|
                    assert_nil project.users.detect {|u| !(u.is_a?(User) && u.active?) }
                  end
                end
                def test_open_scope_on_issues_association
                  assert_kind_of Issue, Project.find(1).issues.open.first
                end
                def test_archive
                  user = @ecookbook.members.first.user
                  @ecookbook.archive
                  @ecookbook.reload
                  assert !@ecookbook.active?
                  assert @ecookbook.archived?
                  assert !user.projects.include?(@ecookbook)
                  # Subproject are also archived
                  assert !@ecookbook.children.empty?
                  assert @ecookbook.descendants.active.empty?
                end
                def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects
                  # Assign an issue of a project to a version of a child project
                  Issue.find(4).update_attribute :fixed_version_id, 4
                  assert_no_difference "Project.count(:all, :conditions => 'status = #{Project::STATUS_ARCHIVED}')" do
                    assert_equal false, @ecookbook.archive
                  end
                  @ecookbook.reload
                  assert @ecookbook.active?
                end
                def test_unarchive
                  user = @ecookbook.members.first.user
                  @ecookbook.archive
                  # A subproject of an archived project can not be unarchived
                  assert !@ecookbook_sub1.unarchive
                  # Unarchive project
                  assert @ecookbook.unarchive
                  @ecookbook.reload
                  assert @ecookbook.active?
                  assert !@ecookbook.archived?
                  assert user.projects.include?(@ecookbook)
                  # Subproject can now be unarchived
                  @ecookbook_sub1.reload
                  assert @ecookbook_sub1.unarchive
                end
                def test_destroy
                  # 2 active members
                  assert_equal 2, @ecookbook.members.size
                  # and 1 is locked
                  assert_equal 3, Member.where('project_id = ?', @ecookbook.id).all.size
                  # some boards
                  assert @ecookbook.boards.any?
                  @ecookbook.destroy
                  # make sure that the project non longer exists
                  assert_raise(ActiveRecord::RecordNotFound) { Project.find(@ecookbook.id) }
                  # make sure related data was removed
                  assert_nil Member.first(:conditions => {:project_id => @ecookbook.id})
                  assert_nil Board.first(:conditions => {:project_id => @ecookbook.id})
                  assert_nil Issue.first(:conditions => {:project_id => @ecookbook.id})
                end
                def test_destroy_should_destroy_subtasks
                  issues = (0..2).to_a.map {Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :subject => 'test')}
                  issues[0].update_attribute :parent_issue_id, issues[1].id
                  issues[2].update_attribute :parent_issue_id, issues[1].id
                  assert_equal 2, issues[1].children.count
                  assert_nothing_raised do
                    Project.find(1).destroy
                  end
                  assert Issue.find_all_by_id(issues.map(&:id)).empty?
                end
                def test_destroying_root_projects_should_clear_data
                  Project.roots.each do |root|
                    root.destroy
                  end
                  assert_equal 0, Project.count, "Projects were not deleted: #{Project.all.inspect}"
                  assert_equal 0, Member.count, "Members were not deleted: #{Member.all.inspect}"
                  assert_equal 0, MemberRole.count
                  assert_equal 0, Issue.count
                  assert_equal 0, Journal.count
                  assert_equal 0, JournalDetail.count
                  assert_equal 0, Attachment.count, "Attachments were not deleted: #{Attachment.all.inspect}"
                  assert_equal 0, EnabledModule.count
                  assert_equal 0, IssueCategory.count
                  assert_equal 0, IssueRelation.count
                  assert_equal 0, Board.count
                  assert_equal 0, Message.count
                  assert_equal 0, News.count
                  assert_equal 0, Query.count(:conditions => "project_id IS NOT NULL")
                  assert_equal 0, Repository.count
                  assert_equal 0, Changeset.count
                  assert_equal 0, Change.count
                  assert_equal 0, Comment.count
                  assert_equal 0, TimeEntry.count
                  assert_equal 0, Version.count
                  assert_equal 0, Watcher.count
                  assert_equal 0, Wiki.count
                  assert_equal 0, WikiPage.count
                  assert_equal 0, WikiContent.count
                  assert_equal 0, WikiContent::Version.count
                  assert_equal 0, Project.connection.select_all("SELECT * FROM projects_trackers").size
                  assert_equal 0, Project.connection.select_all("SELECT * FROM custom_fields_projects").size
                  assert_equal 0, CustomValue.count(:conditions => {:customized_type => ['Project', 'Issue', 'TimeEntry', 'Version']})
                end
                def test_move_an_orphan_project_to_a_root_project
                  sub = Project.find(2)
                  sub.set_parent! @ecookbook
                  assert_equal @ecookbook.id, sub.parent.id
                  @ecookbook.reload
                  assert_equal 4, @ecookbook.children.size
                end
                def test_move_an_orphan_project_to_a_subproject
                  sub = Project.find(2)
                  assert sub.set_parent!(@ecookbook_sub1)
                end
                def test_move_a_root_project_to_a_project
                  sub = @ecookbook
                  assert sub.set_parent!(Project.find(2))
                end
                def test_should_not_move_a_project_to_its_children
                  sub = @ecookbook
                  assert !(sub.set_parent!(Project.find(3)))
                end
                def test_set_parent_should_add_roots_in_alphabetical_order
                  ProjectCustomField.delete_all
                  Project.delete_all
                  Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(nil)
                  Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(nil)
                  Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(nil)
                  Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(nil)
                  assert_equal 4, Project.count
                  assert_equal Project.all.sort_by(&:name), Project.all.sort_by(&:lft)
                end
                def test_set_parent_should_add_children_in_alphabetical_order
                  ProjectCustomField.delete_all
                  parent = Project.create!(:name => 'Parent', :identifier => 'parent')
                  Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(parent)
                  Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(parent)
                  Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(parent)
                  Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(parent)
                  parent.reload
                  assert_equal 4, parent.children.size
                  assert_equal parent.children.all.sort_by(&:name), parent.children.all
                end
                def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy
                  # Parent issue with a hierarchy project's fixed version
                  parent_issue = Issue.find(1)
                  parent_issue.update_attribute(:fixed_version_id, 4)
                  parent_issue.reload
                  assert_equal 4, parent_issue.fixed_version_id
                  # Should keep fixed versions for the issues
                  issue_with_local_fixed_version = Issue.find(5)
                  issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)
                  issue_with_local_fixed_version.reload
                  assert_equal 4, issue_with_local_fixed_version.fixed_version_id
                  # Local issue with hierarchy fixed_version
                  issue_with_hierarchy_fixed_version = Issue.find(13)
                  issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)
                  issue_with_hierarchy_fixed_version.reload
                  assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id
                  # Move project out of the issue's hierarchy
                  moved_project = Project.find(3)
                  moved_project.set_parent!(Project.find(2))
                  parent_issue.reload
                  issue_with_local_fixed_version.reload
                  issue_with_hierarchy_fixed_version.reload
                  assert_equal 4, issue_with_local_fixed_version.fixed_version_id, "Fixed version was not keep on an issue local to the moved project"
                  assert_equal nil, issue_with_hierarchy_fixed_version.fixed_version_id, "Fixed version is still set after moving the Project out of the hierarchy where the version is defined in"
                  assert_equal nil, parent_issue.fixed_version_id, "Fixed version is still set after moving the Version out of the hierarchy for the issue."
                end
                def test_parent
                  p = Project.find(6).parent
                  assert p.is_a?(Project)
                  assert_equal 5, p.id
                end
                def test_ancestors
                  a = Project.find(6).ancestors
                  assert a.first.is_a?(Project)
                  assert_equal [1, 5], a.collect(&:id)
                end
                def test_root
                  r = Project.find(6).root
                  assert r.is_a?(Project)
                  assert_equal 1, r.id
                end
                def test_children
                  c = Project.find(1).children
                  assert c.first.is_a?(Project)
                  assert_equal [5, 3, 4], c.collect(&:id)
                end
                def test_descendants
                  d = Project.find(1).descendants
                  assert d.first.is_a?(Project)
                  assert_equal [5, 6, 3, 4], d.collect(&:id)
                end
                def test_allowed_parents_should_be_empty_for_non_member_user
                  Role.non_member.add_permission!(:add_project)
                  user = User.find(9)
                  assert user.memberships.empty?
                  User.current = user
                  assert Project.new.allowed_parents.compact.empty?
                end
                def test_allowed_parents_with_add_subprojects_permission
                  Role.find(1).remove_permission!(:add_project)
                  Role.find(1).add_permission!(:add_subprojects)
                  User.current = User.find(2)
                  # new project
                  assert !Project.new.allowed_parents.include?(nil)
                  assert Project.new.allowed_parents.include?(Project.find(1))
                  # existing root project
                  assert Project.find(1).allowed_parents.include?(nil)
                  # existing child
                  assert Project.find(3).allowed_parents.include?(Project.find(1))
                  assert !Project.find(3).allowed_parents.include?(nil)
                end
                def test_allowed_parents_with_add_project_permission
                  Role.find(1).add_permission!(:add_project)
                  Role.find(1).remove_permission!(:add_subprojects)
                  User.current = User.find(2)
                  # new project
                  assert Project.new.allowed_parents.include?(nil)
                  assert !Project.new.allowed_parents.include?(Project.find(1))
                  # existing root project
                  assert Project.find(1).allowed_parents.include?(nil)
                  # existing child
                  assert Project.find(3).allowed_parents.include?(Project.find(1))
                  assert Project.find(3).allowed_parents.include?(nil)
                end
                def test_allowed_parents_with_add_project_and_subprojects_permission
                  Role.find(1).add_permission!(:add_project)
                  Role.find(1).add_permission!(:add_subprojects)
                  User.current = User.find(2)
                  # new project
                  assert Project.new.allowed_parents.include?(nil)
                  assert Project.new.allowed_parents.include?(Project.find(1))
                  # existing root project
                  assert Project.find(1).allowed_parents.include?(nil)
                  # existing child
                  assert Project.find(3).allowed_parents.include?(Project.find(1))
                  assert Project.find(3).allowed_parents.include?(nil)
                end
                def test_users_by_role
                  users_by_role = Project.find(1).users_by_role
                  assert_kind_of Hash, users_by_role
                  role = Role.find(1)
                  assert_kind_of Array, users_by_role[role]
                  assert users_by_role[role].include?(User.find(2))
                end
                def test_rolled_up_trackers
                  parent = Project.find(1)
                  parent.trackers = Tracker.find([1,2])
                  child = parent.children.find(3)
                  assert_equal [1, 2], parent.tracker_ids
                  assert_equal [2, 3], child.trackers.collect(&:id)
                  assert_kind_of Tracker, parent.rolled_up_trackers.first
                  assert_equal Tracker.find(1), parent.rolled_up_trackers.first
                  assert_equal [1, 2, 3], parent.rolled_up_trackers.collect(&:id)
                  assert_equal [2, 3], child.rolled_up_trackers.collect(&:id)
                end
                def test_rolled_up_trackers_should_ignore_archived_subprojects
                  parent = Project.find(1)
                  parent.trackers = Tracker.find([1,2])
                  child = parent.children.find(3)
                  child.trackers = Tracker.find([1,3])
                  parent.children.each(&:archive)
                  assert_equal [1,2], parent.rolled_up_trackers.collect(&:id)
                end
-               context "#rolled_up_versions" do
-                 setup do
-                   @project = Project.generate!
-                   @parent_version_1 = Version.generate!(:project => @project)
-                   @parent_version_2 = Version.generate!(:project => @project)
-                 end
-                 should "include the versions for the current project" do
-                   assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions
-                 end
-                 should "include versions for a subproject" do
-                   @subproject = Project.generate!
-                   @subproject.set_parent!(@project)
-                   @subproject_version = Version.generate!(:project => @subproject)
-                   assert_same_elements [
-                                         @parent_version_1,
-                                         @parent_version_2,
-                                         @subproject_version
-                                        ], @project.rolled_up_versions
-                 end
-                 should "include versions for a sub-subproject" do
-                   @subproject = Project.generate!
-                   @subproject.set_parent!(@project)
-                   @sub_subproject = Project.generate!
-                   @sub_subproject.set_parent!(@subproject)
-                   @sub_subproject_version = Version.generate!(:project => @sub_subproject)
-                   @project.reload
-                   assert_same_elements [
-                                         @parent_version_1,
-                                         @parent_version_2,
-                                         @sub_subproject_version
-                                        ], @project.rolled_up_versions
-                 end
+               test "#rolled_up_versions should include the versions for the current project" do
+                 project = Project.generate!
+                 parent_version_1 = Version.generate!(:project => project)
+                 parent_version_2 = Version.generate!(:project => project)
+                 assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions
+               end
+               test "#rolled_up_versions should include versions for a subproject" do
+                 project = Project.generate!
+                 parent_version_1 = Version.generate!(:project => project)
+                 parent_version_2 = Version.generate!(:project => project)
+                 subproject = Project.generate_with_parent!(project)
+                 subproject_version = Version.generate!(:project => subproject)
+                 assert_same_elements [
+                                       parent_version_1,
+                                       parent_version_2,
+                                       subproject_version
+                                      ], project.rolled_up_versions
+               end
+               test "#rolled_up_versions should include versions for a sub-subproject" do
+                 project = Project.generate!
+                 parent_version_1 = Version.generate!(:project => project)
+                 parent_version_2 = Version.generate!(:project => project)
+                 subproject = Project.generate_with_parent!(project)
+                 sub_subproject = Project.generate_with_parent!(subproject)
+                 sub_subproject_version = Version.generate!(:project => sub_subproject)
+                 project.reload
-                 should "only check active projects" do
-                   @subproject = Project.generate!
-                   @subproject.set_parent!(@project)
-                   @subproject_version = Version.generate!(:project => @subproject)
-                   assert @subproject.archive
+                 assert_same_elements [
+                                       parent_version_1,
+                                       parent_version_2,
+                                       sub_subproject_version
+                                      ], project.rolled_up_versions
+               end
-                   @project.reload
+               test "#rolled_up_versions should only check active projects" do
+                 project = Project.generate!
+                 parent_version_1 = Version.generate!(:project => project)
+                 parent_version_2 = Version.generate!(:project => project)
+                 subproject = Project.generate_with_parent!(project)
+                 subproject_version = Version.generate!(:project => subproject)
+                 assert subproject.archive
+                 project.reload
-                   assert !@subproject.active?
-                   assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions
-                 end
+                 assert !subproject.active?
+                 assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions
                end
                def test_shared_versions_none_sharing
                  p = Project.find(5)
                  v = Version.create!(:name => 'none_sharing', :project => p, :sharing => 'none')
                  assert p.shared_versions.include?(v)
                  assert !p.children.first.shared_versions.include?(v)
                  assert !p.root.shared_versions.include?(v)
                  assert !p.siblings.first.shared_versions.include?(v)
                  assert !p.root.siblings.first.shared_versions.include?(v)
                end
                def test_shared_versions_descendants_sharing
                  p = Project.find(5)
                  v = Version.create!(:name => 'descendants_sharing', :project => p, :sharing => 'descendants')
                  assert p.shared_versions.include?(v)
                  assert p.children.first.shared_versions.include?(v)
                  assert !p.root.shared_versions.include?(v)
                  assert !p.siblings.first.shared_versions.include?(v)
                  assert !p.root.siblings.first.shared_versions.include?(v)
                end
                def test_shared_versions_hierarchy_sharing
                  p = Project.find(5)
                  v = Version.create!(:name => 'hierarchy_sharing', :project => p, :sharing => 'hierarchy')
                  assert p.shared_versions.include?(v)
                  assert p.children.first.shared_versions.include?(v)
                  assert p.root.shared_versions.include?(v)
                  assert !p.siblings.first.shared_versions.include?(v)
                  assert !p.root.siblings.first.shared_versions.include?(v)
                end
                def test_shared_versions_tree_sharing
                  p = Project.find(5)
                  v = Version.create!(:name => 'tree_sharing', :project => p, :sharing => 'tree')
                  assert p.shared_versions.include?(v)
                  assert p.children.first.shared_versions.include?(v)
                  assert p.root.shared_versions.include?(v)
                  assert p.siblings.first.shared_versions.include?(v)
                  assert !p.root.siblings.first.shared_versions.include?(v)
                end
                def test_shared_versions_system_sharing
                  p = Project.find(5)
                  v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')
                  assert p.shared_versions.include?(v)
                  assert p.children.first.shared_versions.include?(v)
                  assert p.root.shared_versions.include?(v)
                  assert p.siblings.first.shared_versions.include?(v)
                  assert p.root.siblings.first.shared_versions.include?(v)
                end
                def test_shared_versions
                  parent = Project.find(1)
                  child = parent.children.find(3)
                  private_child = parent.children.find(5)
                  assert_equal [1,2,3], parent.version_ids.sort
                  assert_equal [4], child.version_ids
                  assert_equal [6], private_child.version_ids
                  assert_equal [7], Version.find_all_by_sharing('system').collect(&:id)
                  assert_equal 6, parent.shared_versions.size
                  parent.shared_versions.each do |version|
                    assert_kind_of Version, version
                  end
                  assert_equal [1,2,3,4,6,7], parent.shared_versions.collect(&:id).sort
                end
                def test_shared_versions_should_ignore_archived_subprojects
                  parent = Project.find(1)
                  child = parent.children.find(3)
                  child.archive
                  parent.reload
                  assert_equal [1,2,3], parent.version_ids.sort
                  assert_equal [4], child.version_ids
                  assert !parent.shared_versions.collect(&:id).include?(4)
                end
                def test_shared_versions_visible_to_user
                  user = User.find(3)
                  parent = Project.find(1)
                  child = parent.children.find(5)
                  assert_equal [1,2,3], parent.version_ids.sort
                  assert_equal [6], child.version_ids
                  versions = parent.shared_versions.visible(user)
                  assert_equal 4, versions.size
                  versions.each do |version|
                    assert_kind_of Version, version
                  end
                  assert !versions.collect(&:id).include?(6)
                end
                def test_shared_versions_for_new_project_should_include_system_shared_versions
                  p = Project.find(5)
                  v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')
                  assert_include v, Project.new.shared_versions
                end
                def test_next_identifier
                  ProjectCustomField.delete_all
                  Project.create!(:name => 'last', :identifier => 'p2008040')
                  assert_equal 'p2008041', Project.next_identifier
                end
                def test_next_identifier_first_project
                  Project.delete_all
                  assert_nil Project.next_identifier
                end
                def test_enabled_module_names
                  with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
                    project = Project.new
                    project.enabled_module_names = %w(issue_tracking news)
                    assert_equal %w(issue_tracking news), project.enabled_module_names.sort
                  end
                end
-               context "enabled_modules" do
-                 setup do
-                   @project = Project.find(1)
-                 end
-                 should "define module by names and preserve ids" do
-                   # Remove one module
-                   modules = @project.enabled_modules.slice(0..-2)
-                   assert modules.any?
-                   assert_difference 'EnabledModule.count', -1 do
-                     @project.enabled_module_names = modules.collect(&:name)
-                   end
-                   @project.reload
-                   # Ids should be preserved
-                   assert_equal @project.enabled_module_ids.sort, modules.collect(&:id).sort
-                 end
-                 should "enable a module" do
-                   @project.enabled_module_names = []
-                   @project.reload
-                   assert_equal [], @project.enabled_module_names
-                   #with string
-                   @project.enable_module!("issue_tracking")
-                   assert_equal ["issue_tracking"], @project.enabled_module_names
-                   #with symbol
-                   @project.enable_module!(:gantt)
-                   assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
-                   #don't add a module twice
-                   @project.enable_module!("issue_tracking")
-                   assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
-                 end
-                 should "disable a module" do
-                   #with string
-                   assert @project.enabled_module_names.include?("issue_tracking")
-                   @project.disable_module!("issue_tracking")
-                   assert ! @project.reload.enabled_module_names.include?("issue_tracking")
-                   #with symbol
-                   assert @project.enabled_module_names.include?("gantt")
-                   @project.disable_module!(:gantt)
-                   assert ! @project.reload.enabled_module_names.include?("gantt")
-                   #with EnabledModule object
-                   first_module = @project.enabled_modules.first
-                   @project.disable_module!(first_module)
-                   assert ! @project.reload.enabled_module_names.include?(first_module.name)
+               test "enabled_modules should define module by names and preserve ids" do
+                 @project = Project.find(1)
+                 # Remove one module
+                 modules = @project.enabled_modules.slice(0..-2)
+                 assert modules.any?
+                 assert_difference 'EnabledModule.count', -1 do
+                   @project.enabled_module_names = modules.collect(&:name)
                  end
+                 @project.reload
+                 # Ids should be preserved
+                 assert_equal @project.enabled_module_ids.sort, modules.collect(&:id).sort
+               end
+               test "enabled_modules should enable a module" do
+                 @project = Project.find(1)
+                 @project.enabled_module_names = []
+                 @project.reload
+                 assert_equal [], @project.enabled_module_names
+                 #with string
+                 @project.enable_module!("issue_tracking")
+                 assert_equal ["issue_tracking"], @project.enabled_module_names
+                 #with symbol
+                 @project.enable_module!(:gantt)
+                 assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
+                 #don't add a module twice
+                 @project.enable_module!("issue_tracking")
+                 assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
+               end
+               test "enabled_modules should disable a module" do
+                 @project = Project.find(1)
+                 #with string
+                 assert @project.enabled_module_names.include?("issue_tracking")
+                 @project.disable_module!("issue_tracking")
+                 assert ! @project.reload.enabled_module_names.include?("issue_tracking")
+                 #with symbol
+                 assert @project.enabled_module_names.include?("gantt")
+                 @project.disable_module!(:gantt)
+                 assert ! @project.reload.enabled_module_names.include?("gantt")
+                 #with EnabledModule object
+                 first_module = @project.enabled_modules.first
+                 @project.disable_module!(first_module)
+                 assert ! @project.reload.enabled_module_names.include?(first_module.name)
                end
                def test_enabled_module_names_should_not_recreate_enabled_modules
                  project = Project.find(1)
                  # Remove one module
                  modules = project.enabled_modules.slice(0..-2)
                  assert modules.any?
                  assert_difference 'EnabledModule.count', -1 do
                    project.enabled_module_names = modules.collect(&:name)
                  end
                  project.reload
                  # Ids should be preserved
                  assert_equal project.enabled_module_ids.sort, modules.collect(&:id).sort
                end
                def test_copy_from_existing_project
                  source_project = Project.find(1)
                  copied_project = Project.copy_from(1)
                  assert copied_project
                  # Cleared attributes
                  assert copied_project.id.blank?
                  assert copied_project.name.blank?
                  assert copied_project.identifier.blank?
                  # Duplicated attributes
                  assert_equal source_project.description, copied_project.description
                  assert_equal source_project.enabled_modules, copied_project.enabled_modules
                  assert_equal source_project.trackers, copied_project.trackers
                  # Default attributes
                  assert_equal 1, copied_project.status
                end
                def test_activities_should_use_the_system_activities
                  project = Project.find(1)
                  assert_equal project.activities, TimeEntryActivity.where(:active => true).all
                end
                def test_activities_should_use_the_project_specific_activities
                  project = Project.find(1)
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project})
                  assert overridden_activity.save!
                  assert project.activities.include?(overridden_activity), "Project specific Activity not found"
                end
                def test_activities_should_not_include_the_inactive_project_specific_activities
                  project = Project.find(1)
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.first, :active => false})
                  assert overridden_activity.save!
                  assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity found"
                end
                def test_activities_should_not_include_project_specific_activities_from_other_projects
                  project = Project.find(1)
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(2)})
                  assert overridden_activity.save!
                  assert !project.activities.include?(overridden_activity), "Project specific Activity found on a different project"
                end
                def test_activities_should_handle_nils
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(1), :parent => TimeEntryActivity.first})
                  TimeEntryActivity.delete_all
                  # No activities
                  project = Project.find(1)
                  assert project.activities.empty?
                  # No system, one overridden
                  assert overridden_activity.save!
                  project.reload
                  assert_equal [overridden_activity], project.activities
                end
                def test_activities_should_override_system_activities_with_project_activities
                  project = Project.find(1)
                  parent_activity = TimeEntryActivity.first
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => parent_activity})
                  assert overridden_activity.save!
                  assert project.activities.include?(overridden_activity), "Project specific Activity not found"
                  assert !project.activities.include?(parent_activity), "System Activity found when it should have been overridden"
                end
                def test_activities_should_include_inactive_activities_if_specified
                  project = Project.find(1)
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.first, :active => false})
                  assert overridden_activity.save!
                  assert project.activities(true).include?(overridden_activity), "Inactive Project specific Activity not found"
                end
                test 'activities should not include active System activities if the project has an override that is inactive' do
                  project = Project.find(1)
                  system_activity = TimeEntryActivity.find_by_name('Design')
                  assert system_activity.active?
                  overridden_activity = TimeEntryActivity.create!(:name => "Project", :project => project, :parent => system_activity, :active => false)
                  assert overridden_activity.save!
                  assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity not found"
                  assert !project.activities.include?(system_activity), "System activity found when the project has an inactive override"
                end
                def test_close_completed_versions
                  Version.update_all("status = 'open'")
                  project = Project.find(1)
                  assert_not_nil project.versions.detect {|v| v.completed? && v.status == 'open'}
                  assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}
                  project.close_completed_versions
                  project.reload
                  assert_nil project.versions.detect {|v| v.completed? && v.status != 'closed'}
                  assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}
                end
                context "Project#copy" do
                  setup do
                    ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                    Project.destroy_all :identifier => "copy-test"
                    @source_project = Project.find(2)
                    @project = Project.new(:name => 'Copy Test', :identifier => 'copy-test')
                    @project.trackers = @source_project.trackers
                    @project.enabled_module_names = @source_project.enabled_modules.collect(&:name)
                  end
                  should "copy issues" do
                    @source_project.issues << Issue.generate!(:status => IssueStatus.find_by_name('Closed'),
                                                              :subject => "copy issue status",
                                                              :tracker_id => 1,
                                                              :assigned_to_id => 2,
                                                              :project_id => @source_project.id)
                    assert @project.valid?
                    assert @project.issues.empty?
                    assert @project.copy(@source_project)
                    assert_equal @source_project.issues.size, @project.issues.size
                    @project.issues.each do |issue|
                      assert issue.valid?
                      assert ! issue.assigned_to.blank?
                      assert_equal @project, issue.project
                    end
                    copied_issue = @project.issues.first(:conditions => {:subject => "copy issue status"})
                    assert copied_issue
                    assert copied_issue.status
                    assert_equal "Closed", copied_issue.status.name
                  end
                  should "copy issues assigned to a locked version" do
                    User.current = User.find(1)
                    assigned_version = Version.generate!(:name => "Assigned Issues")
                    @source_project.versions << assigned_version
                    Issue.generate!(:project => @source_project,
                                    :fixed_version_id => assigned_version.id,
                                    :subject => "copy issues assigned to a locked version")
                    assigned_version.update_attribute :status, 'locked'
                    assert @project.copy(@source_project)
                    @project.reload
                    copied_issue = @project.issues.first(:conditions => {:subject => "copy issues assigned to a locked version"})
                    assert copied_issue
                    assert copied_issue.fixed_version
                    assert_equal "Assigned Issues", copied_issue.fixed_version.name # Same name
                    assert_equal 'locked', copied_issue.fixed_version.status
                  end
                  should "change the new issues to use the copied version" do
                    User.current = User.find(1)
                    assigned_version = Version.generate!(:name => "Assigned Issues", :status => 'open')
                    @source_project.versions << assigned_version
                    assert_equal 3, @source_project.versions.size
                    Issue.generate!(:project => @source_project,
                                    :fixed_version_id => assigned_version.id,
                                    :subject => "change the new issues to use the copied version")
                    assert @project.copy(@source_project)
                    @project.reload
                    copied_issue = @project.issues.first(:conditions => {:subject => "change the new issues to use the copied version"})
                    assert copied_issue
                    assert copied_issue.fixed_version
                    assert_equal "Assigned Issues", copied_issue.fixed_version.name # Same name
                    assert_not_equal assigned_version.id, copied_issue.fixed_version.id # Different record
                  end
                  should "keep target shared versions from other project" do
                    assigned_version = Version.generate!(:name => "Assigned Issues", :status => 'open', :project_id => 1, :sharing => 'system')
                    issue = Issue.generate!(:project => @source_project,
                                            :fixed_version => assigned_version,
                                            :subject => "keep target shared versions")
                    assert @project.copy(@source_project)
                    @project.reload
                    copied_issue = @project.issues.first(:conditions => {:subject => "keep target shared versions"})
                    assert copied_issue
                    assert_equal assigned_version, copied_issue.fixed_version
                  end
                  should "copy issue relations" do
                    Setting.cross_project_issue_relations = '1'
                    second_issue = Issue.generate!(:status_id => 5,
                                                   :subject => "copy issue relation",
                                                   :tracker_id => 1,
                                                   :assigned_to_id => 2,
                                                   :project_id => @source_project.id)
                    source_relation = IssueRelation.create!(:issue_from => Issue.find(4),
                                                              :issue_to => second_issue,
                                                              :relation_type => "relates")
                    source_relation_cross_project = IssueRelation.create!(:issue_from => Issue.find(1),
                                                                            :issue_to => second_issue,
                                                                            :relation_type => "duplicates")
                    assert @project.copy(@source_project)
                    assert_equal @source_project.issues.count, @project.issues.count
                    copied_issue = @project.issues.find_by_subject("Issue on project 2") # Was #4
                    copied_second_issue = @project.issues.find_by_subject("copy issue relation")
                    # First issue with a relation on project
                    assert_equal 1, copied_issue.relations.size, "Relation not copied"
                    copied_relation = copied_issue.relations.first
                    assert_equal "relates", copied_relation.relation_type
                    assert_equal copied_second_issue.id, copied_relation.issue_to_id
                    assert_not_equal source_relation.id, copied_relation.id
                    # Second issue with a cross project relation
                    assert_equal 2, copied_second_issue.relations.size, "Relation not copied"
                    copied_relation = copied_second_issue.relations.select {|r| r.relation_type == 'duplicates'}.first
                    assert_equal "duplicates", copied_relation.relation_type
                    assert_equal 1, copied_relation.issue_from_id, "Cross project relation not kept"
                    assert_not_equal source_relation_cross_project.id, copied_relation.id
                  end
                  should "copy issue attachments" do
                    issue = Issue.generate!(:subject => "copy with attachment", :tracker_id => 1, :project_id => @source_project.id)
                    Attachment.create!(:container => issue, :file => uploaded_test_file("testfile.txt", "text/plain"), :author_id => 1)
                    @source_project.issues << issue
                    assert @project.copy(@source_project)
                    copied_issue = @project.issues.first(:conditions => {:subject => "copy with attachment"})
                    assert_not_nil copied_issue
                    assert_equal 1, copied_issue.attachments.count, "Attachment not copied"
                    assert_equal "testfile.txt", copied_issue.attachments.first.filename
                  end
                  should "copy memberships" do
                    assert @project.valid?
                    assert @project.members.empty?
                    assert @project.copy(@source_project)
                    assert_equal @source_project.memberships.size, @project.memberships.size
                    @project.memberships.each do |membership|
                      assert membership
                      assert_equal @project, membership.project
                    end
                  end
                  should "copy memberships with groups and additional roles" do
                    group = Group.create!(:lastname => "Copy group")
                    user = User.find(7)
                    group.users << user
                    # group role
                    Member.create!(:project_id => @source_project.id, :principal => group, :role_ids => [2])
                    member = Member.find_by_user_id_and_project_id(user.id, @source_project.id)
                    # additional role
                    member.role_ids = [1]
                    assert @project.copy(@source_project)
                    member = Member.find_by_user_id_and_project_id(user.id, @project.id)
                    assert_not_nil member
                    assert_equal [1, 2], member.role_ids.sort
                  end
                  should "copy project specific queries" do
                    assert @project.valid?
                    assert @project.queries.empty?
                    assert @project.copy(@source_project)
                    assert_equal @source_project.queries.size, @project.queries.size
                    @project.queries.each do |query|
                      assert query
                      assert_equal @project, query.project
                    end
                    assert_equal @source_project.queries.map(&:user_id).sort, @project.queries.map(&:user_id).sort
                  end
                  should "copy versions" do
                    @source_project.versions << Version.generate!
                    @source_project.versions << Version.generate!
                    assert @project.versions.empty?
                    assert @project.copy(@source_project)
                    assert_equal @source_project.versions.size, @project.versions.size
                    @project.versions.each do |version|
                      assert version
                      assert_equal @project, version.project
                    end
                  end
                  should "copy wiki" do
                    assert_difference 'Wiki.count' do
                      assert @project.copy(@source_project)
                    end
                    assert @project.wiki
                    assert_not_equal @source_project.wiki, @project.wiki
                    assert_equal "Start page", @project.wiki.start_page
                  end
                  should "copy wiki pages and content with hierarchy" do
                    assert_difference 'WikiPage.count', @source_project.wiki.pages.size do
                      assert @project.copy(@source_project)
                    end
                    assert @project.wiki
                    assert_equal @source_project.wiki.pages.size, @project.wiki.pages.size
                    @project.wiki.pages.each do |wiki_page|
                      assert wiki_page.content
                      assert !@source_project.wiki.pages.include?(wiki_page)
                    end
                    parent = @project.wiki.find_page('Parent_page')
                    child1 = @project.wiki.find_page('Child_page_1')
                    child2 = @project.wiki.find_page('Child_page_2')
                    assert_equal parent, child1.parent
                    assert_equal parent, child2.parent
                  end
                  should "copy issue categories" do
                    assert @project.copy(@source_project)
                    assert_equal 2, @project.issue_categories.size
                    @project.issue_categories.each do |issue_category|
                      assert !@source_project.issue_categories.include?(issue_category)
                    end
                  end
                  should "copy boards" do
                    assert @project.copy(@source_project)
                    assert_equal 1, @project.boards.size
                    @project.boards.each do |board|
                      assert !@source_project.boards.include?(board)
                    end
                  end
                  should "change the new issues to use the copied issue categories" do
                    issue = Issue.find(4)
                    issue.update_attribute(:category_id, 3)
                    assert @project.copy(@source_project)
                    @project.issues.each do |issue|
                      assert issue.category
                      assert_equal "Stock management", issue.category.name # Same name
                      assert_not_equal IssueCategory.find(3), issue.category # Different record
                    end
                  end
                  should "limit copy with :only option" do
                    assert @project.members.empty?
                    assert @project.issue_categories.empty?
                    assert @source_project.issues.any?
                    assert @project.copy(@source_project, :only => ['members', 'issue_categories'])
                    assert @project.members.any?
                    assert @project.issue_categories.any?
                    assert @project.issues.empty?
                  end
                end
                def test_copy_should_copy_subtasks
                  source = Project.generate!(:tracker_ids => [1])
                  issue = Issue.generate_with_descendants!(:project => source)
                  project = Project.new(:name => 'Copy', :identifier => 'copy', :tracker_ids => [1])
                  assert_difference 'Project.count' do
                    assert_difference 'Issue.count', 1+issue.descendants.count do
                      assert project.copy(source.reload)
                    end
                  end
                  copy = Issue.where(:parent_id => nil).order("id DESC").first
                  assert_equal project, copy.project
                  assert_equal issue.descendants.count, copy.descendants.count
                  child_copy = copy.children.detect {|c| c.subject == 'Child1'}
                  assert child_copy.descendants.any?
                end
                context "#start_date" do
                  setup do
                    ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                    @project = Project.generate!(:identifier => 'test0')
                    @project.trackers << Tracker.generate!
                  end
                  should "be nil if there are no issues on the project" do
                    assert_nil @project.start_date
                  end
                  should "be tested when issues have no start date"
                  should "be the earliest start date of it's issues" do
                    early = 7.days.ago.to_date
                    Issue.generate!(:project => @project, :start_date => Date.today)
                    Issue.generate!(:project => @project, :start_date => early)
                    assert_equal early, @project.start_date
                  end
                end
                context "#due_date" do
                  setup do
                    ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                    @project = Project.generate!(:identifier => 'test0')
                    @project.trackers << Tracker.generate!
                  end
                  should "be nil if there are no issues on the project" do
                    assert_nil @project.due_date
                  end
                  should "be tested when issues have no due date"
                  should "be the latest due date of it's issues" do
                    future = 7.days.from_now.to_date
                    Issue.generate!(:project => @project, :due_date => future)
                    Issue.generate!(:project => @project, :due_date => Date.today)
                    assert_equal future, @project.due_date
                  end
                  should "be the latest due date of it's versions" do
                    future = 7.days.from_now.to_date
                    @project.versions << Version.generate!(:effective_date => future)
                    @project.versions << Version.generate!(:effective_date => Date.today)
                    assert_equal future, @project.due_date
                  end
                  should "pick the latest date from it's issues and versions" do
                    future = 7.days.from_now.to_date
                    far_future = 14.days.from_now.to_date
                    Issue.generate!(:project => @project, :due_date => far_future)
                    @project.versions << Version.generate!(:effective_date => future)
                    assert_equal far_future, @project.due_date
                  end
                end
                context "Project#completed_percent" do
                  setup do
                    ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                    @project = Project.generate!(:identifier => 'test0')
                    @project.trackers << Tracker.generate!
                  end
                  context "no versions" do
                    should "be 100" do
                      assert_equal 100, @project.completed_percent
                    end
                  end
                  context "with versions" do
                    should "return 0 if the versions have no issues" do
                      Version.generate!(:project => @project)
                      Version.generate!(:project => @project)
                      assert_equal 0, @project.completed_percent
                    end
                    should "return 100 if the version has only closed issues" do
                      v1 = Version.generate!(:project => @project)
                      Issue.generate!(:project => @project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v1)
                      v2 = Version.generate!(:project => @project)
                      Issue.generate!(:project => @project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v2)
                      assert_equal 100, @project.completed_percent
                    end
                    should "return the averaged completed percent of the versions (not weighted)" do
                      v1 = Version.generate!(:project => @project)
                      Issue.generate!(:project => @project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v1)
                      v2 = Version.generate!(:project => @project)
                      Issue.generate!(:project => @project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v2)
                      assert_equal 50, @project.completed_percent
                    end
                  end
                end
                context "#notified_users" do
                  setup do
                    @project = Project.generate!
                    @role = Role.generate!
                    @user_with_membership_notification = User.generate!(:mail_notification => 'selected')
                    Member.create!(:project => @project, :roles => [@role], :principal => @user_with_membership_notification, :mail_notification => true)
                    @all_events_user = User.generate!(:mail_notification => 'all')
                    Member.create!(:project => @project, :roles => [@role], :principal => @all_events_user)
                    @no_events_user = User.generate!(:mail_notification => 'none')
                    Member.create!(:project => @project, :roles => [@role], :principal => @no_events_user)
                    @only_my_events_user = User.generate!(:mail_notification => 'only_my_events')
                    Member.create!(:project => @project, :roles => [@role], :principal => @only_my_events_user)
                    @only_assigned_user = User.generate!(:mail_notification => 'only_assigned')
                    Member.create!(:project => @project, :roles => [@role], :principal => @only_assigned_user)
                    @only_owned_user = User.generate!(:mail_notification => 'only_owner')
                    Member.create!(:project => @project, :roles => [@role], :principal => @only_owned_user)
                  end
                  should "include members with a mail notification" do
                    assert @project.notified_users.include?(@user_with_membership_notification)
                  end
                  should "include users with the 'all' notification option" do
                    assert @project.notified_users.include?(@all_events_user)
                  end
                  should "not include users with the 'none' notification option" do
                    assert !@project.notified_users.include?(@no_events_user)
                  end
                  should "not include users with the 'only_my_events' notification option" do
                    assert !@project.notified_users.include?(@only_my_events_user)
                  end
                  should "not include users with the 'only_assigned' notification option" do
                    assert !@project.notified_users.include?(@only_assigned_user)
                  end
                  should "not include users with the 'only_owner' notification option" do
                    assert !@project.notified_users.include?(@only_owned_user)
                  end
                end
              end

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