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 +2 -4

             # 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
+              test "Attachmnet.attach_files should attach the file" 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)
               end
-                should "add unsaved files to the object as unsaved attachments" do
+              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
-              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 +23 -36

             # 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
+                test '#authenticate with a valid LDAP user should return the user attributes' do
-                  setup do
+                  auth = AuthSourceLdap.find(1)
-                    @auth = AuthSourceLdap.find(1)
+                  auth.update_attribute :onthefly_register, true
-                    @auth.update_attribute :onthefly_register, true
-                  end
-                  context 'with a valid LDAP user' do
+                  attributes =  auth.authenticate('example1','123456')
-                    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]
+                  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
-                  end
-                  context 'with an invalid LDAP user' do
+                test '#authenticate with an invalid LDAP user should return nil' do
-                    should 'return nil' do
+                  auth = AuthSourceLdap.find(1)
-                      assert_equal nil, @auth.authenticate('nouser','123456')
+                  assert_equal nil, auth.authenticate('nouser','123456')
-                    end
                 end
-                  context 'without a login' do
+                test '#authenticate without a login should return nil' do
-                    should 'return nil' do
+                  auth = AuthSourceLdap.find(1)
-                      assert_equal nil, @auth.authenticate('','123456')
+                  assert_equal nil, auth.authenticate('','123456')
-                    end
                 end
-                  context 'without a password' do
+                test '#authenticate without a password should return nil' do
-                    should 'return nil' do
+                  auth = AuthSourceLdap.find(1)
-                      assert_equal nil, @auth.authenticate('edavis','')
+                  assert_equal nil, auth.authenticate('edavis','')
-                    end
                 end
-                  context 'without filter' do
+                test '#authenticate without filter should return any user' do
-                    should 'return any user' do
+                  auth = AuthSourceLdap.find(1)
-                      assert @auth.authenticate('example1','123456')
+                  assert auth.authenticate('example1','123456')
-                      assert @auth.authenticate('edavis', '123456')
+                  assert auth.authenticate('edavis', '123456')
-                    end
                 end
-                  context 'with filter' do
+                test '#authenticate with filter should return user who matches the filter only' do
-                    setup do
+                  auth = AuthSourceLdap.find(1)
-                      @auth.filter = "(mail=*@redmine.org)"
+                  auth.filter = "(mail=*@redmine.org)"
-                    end
-                    should 'return user who matches the filter only' do
+                  assert auth.authenticate('example1','123456')
-                      assert @auth.authenticate('example1','123456')
+                  assert_nil auth.authenticate('edavis', '123456')
-                      assert_nil @auth.authenticate('edavis', '123456')
-                    end
-                  end
                 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 +56 -108

             # 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
+              test "#copy should not create a journal" do
-                setup do
+                copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)
-                  @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
-                should "allow assigned_to changes" do
+              test "#copy should allow assigned_to changes" do
-                  copy = @issue.copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)
+                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
+              test "#copy should allow status changes" do
-                  copy = @issue.copy(:project_id => 3, :tracker_id => 2, :status_id => 2)
+                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
+              test "#copy should allow start date changes" do
                 date = Date.today
-                  copy = @issue.copy(:project_id => 3, :tracker_id => 2, :start_date => date)
+                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
+              test "#copy should allow due date changes" do
                 date = Date.today
-                  copy = @issue.copy(:project_id => 3, :tracker_id => 2, :due_date => date)
+                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
+              test "#copy should set current user as author" do
                 User.current = User.find(9)
-                  copy = @issue.copy(:project_id => 3, :tracker_id => 2)
+                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
+              test "#copy 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 = 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
-              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
+              test "#behind_schedule? should be false if the issue has no start_date" 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
-                should "be false if the issue has no end_date" do
+              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
+              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
+              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
+              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
-              end
-              context "#assignable_users" do
+              test "#assignable_users should be Users" do
-                should "be Users" do
                 assert_kind_of User, Issue.find(1).assignable_users.first
               end
-                should "include the issue author" do
+              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
-                should "include the current assignee" do
+              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
-                should "not show the issue author twice" do
+              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
               end
-                context "with issue_group_assignment" do
+              test "#assignable_users with issue_group_assignment should include groups" do
-                  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
-                end
-                context "without issue_group_assignment" do
+              test "#assignable_users without issue_group_assignment should not include groups" do
-                  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
-                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
+              test "#done_ratio should use the issue_status according to Setting.issue_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
-                teardown do
-                  Setting.issue_done_ratio = 'issue_field'
-                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
+                with_settings :issue_done_ratio => 'issue_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
+                with_settings :issue_done_ratio => 'issue_status' do
                   assert_equal 50, @issue.done_ratio
                   assert_equal 0, @issue2.done_ratio
                 end
               end
-              end
-              context "#update_done_ratio_from_issue_status" do
+              test "#update_done_ratio_from_issue_status should update done_ratio according to Setting.issue_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
-                context "with Setting.issue_done_ratio using the issue_field" do
-                  setup do
-                    Setting.issue_done_ratio = 'issue_field'
-                  end
-                  should "not change the issue" do
+                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
-                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
+                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
               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
+              test "Issue#recipients should include project recipients" do
-                setup do
+                issue = Issue.generate!
-                  @project = Project.find(1)
+                assert issue.project.recipients.present?
-                  @author = User.generate!
+                issue.project.recipients.each do |project_recipient|
-                  @assignee = User.generate!
+                  assert issue.recipients.include?(project_recipient)
-                  @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
+              test "Issue#recipients should include the author if the author is active" do
-                  assert @issue.author, "No author set for Issue"
+                issue = Issue.generate!(:author => User.generate!)
-                  assert @issue.recipients.include?(@issue.author.mail)
+                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
+              test "Issue#recipients should include the assigned to user if the assigned to user is active" do
-                  assert @issue.assigned_to, "No assigned_to set for Issue"
+                issue = Issue.generate!(:assigned_to => User.generate!)
-                  assert @issue.recipients.include?(@issue.assigned_to.mail)
+                assert issue.assigned_to, "No assigned_to set for Issue"
+                assert issue.recipients.include?(issue.assigned_to.mail)
               end
-                should "not include users who opt out of all email" do
+              test "Issue#recipients should not include users who opt out of all email" do
-                  @author.update_attribute(:mail_notification, :none)
+                issue = Issue.generate!(:author => User.generate!)
+                issue.author.update_attribute(:mail_notification, :none)
-                  assert !@issue.recipients.include?(@issue.author.mail)
+                assert !issue.recipients.include?(issue.author.mail)
               end
-                should "not include the issue author if they are only notified of assigned issues" do
+              test "Issue#recipients should not include the issue author if they are only notified of assigned issues" do
-                  @author.update_attribute(:mail_notification, :only_assigned)
+                issue = Issue.generate!(:author => User.generate!)
+                issue.author.update_attribute(:mail_notification, :only_assigned)
-                  assert !@issue.recipients.include?(@issue.author.mail)
+                assert !issue.recipients.include?(issue.author.mail)
               end
-                should "not include the assigned user if they are only notified of owned issues" do
+              test "Issue#recipients should not include the assigned user if they are only notified of owned issues" do
-                  @assignee.update_attribute(:mail_notification, :only_owner)
+                issue = Issue.generate!(:assigned_to => User.generate!)
+                issue.assigned_to.update_attribute(:mail_notification, :only_owner)
-                  assert !@issue.recipients.include?(@issue.assigned_to.mail)
+                assert !issue.recipients.include?(issue.assigned_to.mail)
-                end
               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 +10 -28

             # 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
+              test "truncate emails with no setting should add the entire email into the issue" do
-                context "with no setting" do
+                with_settings :mail_handler_body_delimiters => '' 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
               end
-                context "with a single string" do
+              test "truncate emails with a single string should truncate the email at the delimiter for the issue" do
-                  setup do
+                with_settings :mail_handler_body_delimiters => '---' 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
               end
-                context "with a single quoted reply (e.g. reply to a Redmine email notification)" do
+              test "truncate emails with a single quoted reply should truncate the email at the delimiter with the quoted reply symbols (>)" do
-                  setup do
+                with_settings :mail_handler_body_delimiters => '--- Reply above. Do not remove this line. ---' 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
               end
-                context "with multiple quoted replies (e.g. reply to a reply of a Redmine email notification)" do
+              test "truncate emails with multiple quoted replies should truncate the email at the delimiter with the quoted reply symbols (>)" do
-                  setup do
+                with_settings :mail_handler_body_delimiters => '--- Reply above. Do not remove this line. ---' 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
               end
-                context "with multiple strings" do
+              test "truncate emails with multiple strings should truncate the email at the first delimiter found (BREAK)" do
-                  setup do
+                with_settings :mail_handler_body_delimiters => "---\nBREAK" 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
               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 +14 -18

             # 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
+              test "#issue_add should notify project members" do
-                setup do
+                issue = Issue.find(1)
-                  ActionMailer::Base.deliveries.clear
+                assert Mailer.issue_add(issue).deliver
-                  Setting.bcc_recipients = '1'
-                  @issue = Issue.find(1)
-                end
-                should "notify project members" do
-                  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
+              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 Mailer.issue_add(issue).deliver
                 assert !last_email.bcc.include?('dlopper@somenet.foo')
               end
-                should "notify issue watchers" do
+              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
-                  Watcher.create!(:watchable => @issue, :user => user)
+                Watcher.create!(:watchable => issue, :user => user)
-                  assert Mailer.issue_add(@issue).deliver
+                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
+              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)
+                Watcher.create!(:watchable => issue, :user => user)
                 Role.non_member.remove_permission!(:view_issues)
-                  assert Mailer.issue_add(@issue).deliver
+                assert Mailer.issue_add(issue).deliver
                 assert !last_email.bcc.include?(user.mail)
               end
-              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 +22 -40

             # 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
+              test "like scope should search login" do
-                setup do
+                results = Principal.like('jsmi')
-                  Principal.create!(:login => 'login')
-                  Principal.create!(:login => 'login2')
-                  Principal.create!(:firstname => 'firstname')
+                assert results.any?
-                  Principal.create!(:firstname => 'firstname2')
+                assert results.all? {|u| u.login.match(/jsmi/i) }
-                  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
+              test "like scope should search firstname" do
-                  results = Principal.like('login')
+                results = Principal.like('john')
-                  assert_equal 2, results.count
+                assert results.any?
-                  assert results.all? {|u| u.login.match(/login/) }
+                assert results.all? {|u| u.firstname.match(/john/i) }
               end
-                should "search firstname" do
+              test "like scope should search lastname" do
-                  results = Principal.like('firstname')
+                results = Principal.like('smi')
-                  assert_equal 2, results.count
+                assert results.any?
-                  assert results.all? {|u| u.firstname.match(/firstname/) }
+                assert results.all? {|u| u.lastname.match(/smi/i) }
               end
-                should "search lastname" do
+              test "like scope should search mail" do
-                  results = Principal.like('lastname')
+                results = Principal.like('somenet')
-                  assert_equal 2, results.count
+                assert results.any?
-                  assert results.all? {|u| u.lastname.match(/lastname/) }
+                assert results.all? {|u| u.mail.match(/somenet/i) }
               end
-                should "search mail" do
+              test "like scope should search firstname and lastname" do
-                  results = Principal.like('mail')
+                results = Principal.like('john smi')
-                  assert_equal 2, results.count
-                  assert results.all? {|u| u.mail.match(/mail/) }
-                end
-                should "search firstname and lastname" do
-                  results = Principal.like('david palm')
                 assert_equal 1, results.count
-                  assert_equal @palmer, results.first
+                assert_equal User.find(2), results.first
               end
-                should "search lastname and firstname" do
+              test "like scope should search lastname and firstname" do
-                  results = Principal.like('palmer davi')
+                results = Principal.like('smith joh')
                 assert_equal 1, results.count
-                  assert_equal @palmer, results.first
+                assert_equal User.find(2), results.first
-                end
               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 +46 -51

             # 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
+              test "#rolled_up_versions should include the versions for the current project" do
-                setup do
+                project = Project.generate!
-                  @project = Project.generate!
+                parent_version_1 = Version.generate!(:project => project)
-                  @parent_version_1 = Version.generate!(:project => @project)
+                parent_version_2 = 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
-                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
+              test "#rolled_up_versions should include versions for a subproject" do
-                  @subproject = Project.generate!
+                project = Project.generate!
-                  @subproject.set_parent!(@project)
+                parent_version_1 = Version.generate!(:project => project)
-                  @subproject_version = Version.generate!(:project => @subproject)
+                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_1,
-                                        @parent_version_2,
+                                      parent_version_2,
-                                        @subproject_version
+                                      subproject_version
-                                       ], @project.rolled_up_versions
+                                     ], project.rolled_up_versions
-                end
+              end
-                should "include versions for a sub-subproject" do
+              test "#rolled_up_versions should include versions for a sub-subproject" do
-                  @subproject = Project.generate!
+                project = Project.generate!
-                  @subproject.set_parent!(@project)
+                parent_version_1 = Version.generate!(:project => project)
-                  @sub_subproject = Project.generate!
+                parent_version_2 = Version.generate!(:project => project)
-                  @sub_subproject.set_parent!(@subproject)
+                subproject = Project.generate_with_parent!(project)
-                  @sub_subproject_version = Version.generate!(:project => @sub_subproject)
+                sub_subproject = Project.generate_with_parent!(subproject)
+                sub_subproject_version = Version.generate!(:project => sub_subproject)
-                  @project.reload
+                project.reload
                 assert_same_elements [
-                                        @parent_version_1,
+                                      parent_version_1,
-                                        @parent_version_2,
+                                      parent_version_2,
-                                        @sub_subproject_version
+                                      sub_subproject_version
-                                       ], @project.rolled_up_versions
+                                     ], project.rolled_up_versions
-                end
+              end
-                should "only check active projects" do
+              test "#rolled_up_versions should only check active projects" do
-                  @subproject = Project.generate!
+                project = Project.generate!
-                  @subproject.set_parent!(@project)
+                parent_version_1 = Version.generate!(:project => project)
-                  @subproject_version = Version.generate!(:project => @subproject)
+                parent_version_2 = Version.generate!(:project => project)
-                  assert @subproject.archive
+                subproject = Project.generate_with_parent!(project)
+                subproject_version = Version.generate!(:project => subproject)
-                  @project.reload
+                assert subproject.archive
+                project.reload
-                  assert !@subproject.active?
+                assert !subproject.active?
-                  assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions
+                assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions
-                end
               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
+              test "enabled_modules should define module by names and preserve ids" 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
+              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
-                should "disable a module" do
+              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
-              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