jro_apps/redmine Commit - r15678:bf5dade8df89

Use assert_nil instead of assert_equal....

Jean-Philippe Lang -

r15678:bf5dade8df89

parent child

Context file:

r15678:bf5dade8df89

Expand all files

test/functional/project_enumerations_controller_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 ProjectEnumerationsControllerTest < Redmine::ControllerTest
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :enumerations, :users, :issue_categories,
                         :projects_trackers,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules,
                         :custom_fields, :custom_fields_projects,
                         :custom_fields_trackers, :custom_values,
                         :time_entries
                self.use_transactional_fixtures = false
                def setup
                  @request.session[:user_id] = nil
                  Setting.default_language = 'en'
                end
                def test_update_to_override_system_activities
                  @request.session[:user_id] = 2 # manager
                  billable_field = TimeEntryActivityCustomField.find_by_name("Billable")
                  put :update, :project_id => 1, :enumerations => {
                    "9"=> {"parent_id"=>"9", "custom_field_values"=>{"7" => "1"}, "active"=>"0"}, # Design, De-activate
                    "10"=> {"parent_id"=>"10", "custom_field_values"=>{"7"=>"0"}, "active"=>"1"}, # Development, Change custom value
                    "14"=>{"parent_id"=>"14", "custom_field_values"=>{"7"=>"1"}, "active"=>"1"}, # Inactive Activity, Activate with custom value
                    "11"=>{"parent_id"=>"11", "custom_field_values"=>{"7"=>"1"}, "active"=>"1"} # QA, no changes
                  }
                  assert_response :redirect
                  assert_redirected_to '/projects/ecookbook/settings/activities'
                  # Created project specific activities...
                  project = Project.find('ecookbook')
                  # ... Design
                  design = project.time_entry_activities.find_by_name("Design")
                  assert design, "Project activity not found"
                  assert_equal 9, design.parent_id # Relate to the system activity
                  assert_not_equal design.parent.id, design.id # Different records
                  assert_equal design.parent.name, design.name # Same name
                  assert !design.active?
                  # ... Development
                  development = project.time_entry_activities.find_by_name("Development")
                  assert development, "Project activity not found"
                  assert_equal 10, development.parent_id # Relate to the system activity
                  assert_not_equal development.parent.id, development.id # Different records
                  assert_equal development.parent.name, development.name # Same name
                  assert development.active?
                  assert_equal "0", development.custom_value_for(billable_field).value
                  # ... Inactive Activity
                  previously_inactive = project.time_entry_activities.find_by_name("Inactive Activity")
                  assert previously_inactive, "Project activity not found"
                  assert_equal 14, previously_inactive.parent_id # Relate to the system activity
                  assert_not_equal previously_inactive.parent.id, previously_inactive.id # Different records
                  assert_equal previously_inactive.parent.name, previously_inactive.name # Same name
                  assert previously_inactive.active?
                  assert_equal "1", previously_inactive.custom_value_for(billable_field).value
                  # ... QA
-                 assert_equal nil, project.time_entry_activities.find_by_name("QA"), "Custom QA activity created when it wasn't modified"
+                 assert_nil project.time_entry_activities.find_by_name("QA"), "Custom QA activity created when it wasn't modified"
                end
                def test_update_will_update_project_specific_activities
                  @request.session[:user_id] = 2 # manager
                  project_activity = TimeEntryActivity.new({
                                                             :name => 'Project Specific',
                                                             :parent => TimeEntryActivity.first,
                                                             :project => Project.find(1),
                                                             :active => true
                                                           })
                  assert project_activity.save
                  project_activity_two = TimeEntryActivity.new({
                                                                 :name => 'Project Specific Two',
                                                                 :parent => TimeEntryActivity.last,
                                                                 :project => Project.find(1),
                                                                 :active => true
                                                               })
                  assert project_activity_two.save
                  put :update, :project_id => 1, :enumerations => {
                    project_activity.id => {"custom_field_values"=>{"7" => "1"}, "active"=>"0"}, # De-activate
                    project_activity_two.id => {"custom_field_values"=>{"7" => "1"}, "active"=>"0"} # De-activate
                  }
                  assert_response :redirect
                  assert_redirected_to '/projects/ecookbook/settings/activities'
                  # Created project specific activities...
                  project = Project.find('ecookbook')
                  assert_equal 2, project.time_entry_activities.count
                  activity_one = project.time_entry_activities.find_by_name(project_activity.name)
                  assert activity_one, "Project activity not found"
                  assert_equal project_activity.id, activity_one.id
                  assert !activity_one.active?
                  activity_two = project.time_entry_activities.find_by_name(project_activity_two.name)
                  assert activity_two, "Project activity not found"
                  assert_equal project_activity_two.id, activity_two.id
                  assert !activity_two.active?
                end
                def test_update_when_creating_new_activities_will_convert_existing_data
                  assert_equal 3, TimeEntry.where(:activity_id => 9, :project_id => 1).count
                  @request.session[:user_id] = 2 # manager
                  put :update, :project_id => 1, :enumerations => {
                    "9"=> {"parent_id"=>"9", "custom_field_values"=>{"7" => "1"}, "active"=>"0"} # Design, De-activate
                  }
                  assert_response :redirect
                  # No more TimeEntries using the system activity
                  assert_equal 0, TimeEntry.where(:activity_id => 9, :project_id => 1).count,
                               "Time Entries still assigned to system activities"
                  # All TimeEntries using project activity
                  project_specific_activity = TimeEntryActivity.find_by_parent_id_and_project_id(9, 1)
                  assert_equal 3, TimeEntry.where(:activity_id => project_specific_activity.id,
                                                  :project_id => 1).count
                               "No Time Entries assigned to the project activity"
                end
                def test_update_when_creating_new_activities_will_not_convert_existing_data_if_an_exception_is_raised
                  # TODO: Need to cause an exception on create but these tests
                  # aren't setup for mocking.  Just create a record now so the
                  # second one is a dupicate
                  parent = TimeEntryActivity.find(9)
                  TimeEntryActivity.create!({:name => parent.name, :project_id => 1,
                                             :position => parent.position, :active => true, :parent_id => 9})
                  TimeEntry.create!({:project_id => 1, :hours => 1.0, :user => User.find(1),
                                     :issue_id => 3, :activity_id => 10, :spent_on => '2009-01-01'})
                  assert_equal 3, TimeEntry.where(:activity_id => 9, :project_id => 1).count
                  assert_equal 1, TimeEntry.where(:activity_id => 10, :project_id => 1).count
                  @request.session[:user_id] = 2 # manager
                  put :update, :project_id => 1, :enumerations => {
                    # Design
                    "9"=> {"parent_id"=>"9", "custom_field_values"=>{"7" => "1"}, "active"=>"0"},
                    # Development, Change custom value
                    "10"=> {"parent_id"=>"10", "custom_field_values"=>{"7"=>"0"}, "active"=>"1"}
                  }
                  assert_response :redirect
                  # TimeEntries shouldn't have been reassigned on the failed record
                  assert_equal 3, TimeEntry.where(:activity_id => 9,
                                                  :project_id => 1).count
                               "Time Entries are not assigned to system activities"
                  # TimeEntries shouldn't have been reassigned on the saved record either
                  assert_equal 1, TimeEntry.where(:activity_id => 10,
                                                  :project_id => 1).count
                               "Time Entries are not assigned to system activities"
                end
                def test_destroy
                  @request.session[:user_id] = 2 # manager
                  project_activity = TimeEntryActivity.new({
                                                             :name => 'Project Specific',
                                                             :parent => TimeEntryActivity.first,
                                                             :project => Project.find(1),
                                                             :active => true
                                                           })
                  assert project_activity.save
                  project_activity_two = TimeEntryActivity.new({
                                                                 :name => 'Project Specific Two',
                                                                 :parent => TimeEntryActivity.last,
                                                                 :project => Project.find(1),
                                                                 :active => true
                                                               })
                  assert project_activity_two.save
                  delete :destroy, :project_id => 1
                  assert_response :redirect
                  assert_redirected_to '/projects/ecookbook/settings/activities'
                  assert_nil TimeEntryActivity.find_by_id(project_activity.id)
                  assert_nil TimeEntryActivity.find_by_id(project_activity_two.id)
                end
                def test_destroy_should_reassign_time_entries_back_to_the_system_activity
                  @request.session[:user_id] = 2 # manager
                  project_activity = TimeEntryActivity.new({
                                                             :name => 'Project Specific Design',
                                                             :parent => TimeEntryActivity.find(9),
                                                             :project => Project.find(1),
                                                             :active => true
                                                           })
                  assert project_activity.save
                  assert TimeEntry.where(["project_id = ? AND activity_id = ?", 1, 9]).
                           update_all("activity_id = '#{project_activity.id}'")
                  assert_equal 3, TimeEntry.where(:activity_id => project_activity.id,
                                                  :project_id => 1).count
                  delete :destroy, :project_id => 1
                  assert_response :redirect
                  assert_redirected_to '/projects/ecookbook/settings/activities'
                  assert_nil TimeEntryActivity.find_by_id(project_activity.id)
                  assert_equal 0, TimeEntry.where(
                                    :activity_id => project_activity.id,
                                    :project_id => 1
                                  ).count,
                               "TimeEntries still assigned to project specific activity"
                  assert_equal 3, TimeEntry.where(
                                    :activity_id => 9,
                                    :project_id => 1
                                  ).count,
                               "TimeEntries still assigned to project specific activity"
                end
              end

test/functional/users_controller_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 UsersControllerTest < Redmine::ControllerTest
                include Redmine::I18n
                fixtures :users, :email_addresses, :projects, :members, :member_roles, :roles,
                         :custom_fields, :custom_values, :groups_users,
                         :auth_sources,
                         :enabled_modules,
                         :issues, :issue_statuses,
                         :trackers
                def setup
                  User.current = nil
                  @request.session[:user_id] = 1 # admin
                end
                def test_index
                  get :index
                  assert_response :success
                  assert_select 'table.users'
                  assert_select 'tr.user.active'
                  assert_select 'tr.user.locked', 0
                end
                def test_index_with_status_filter
                  get :index, :params => {:status => 3}
                  assert_response :success
                  assert_select 'tr.user.active', 0
                  assert_select 'tr.user.locked'
                end
                def test_index_with_name_filter
                  get :index, :params => {:name => 'john'}
                  assert_response :success
                  assert_select 'tr.user td.username', :text => 'jsmith'
                  assert_select 'tr.user', 1
                end
                def test_index_with_group_filter
                  get :index, :params => {:group_id => '10'}
                  assert_response :success
                  assert_select 'tr.user', Group.find(10).users.count
                  assert_select 'select[name=group_id]' do
                    assert_select 'option[value="10"][selected=selected]'
                  end
                end
                def test_show
                  @request.session[:user_id] = nil
                  get :show, :params => {:id => 2}
                  assert_response :success
                  assert_select 'h2', :text => /John Smith/
                end
                def test_show_should_display_visible_custom_fields
                  @request.session[:user_id] = nil
                  UserCustomField.find_by_name('Phone number').update_attribute :visible, true
                  get :show, :params => {:id => 2}
                  assert_response :success
                  assert_select 'li', :text => /Phone number/
                end
                def test_show_should_not_display_hidden_custom_fields
                  @request.session[:user_id] = nil
                  UserCustomField.find_by_name('Phone number').update_attribute :visible, false
                  get :show, :params => {:id => 2}
                  assert_response :success
                  assert_select 'li', :text => /Phone number/, :count => 0
                end
                def test_show_should_not_fail_when_custom_values_are_nil
                  user = User.find(2)
                  # Create a custom field to illustrate the issue
                  custom_field = CustomField.create!(:name => 'Testing', :field_format => 'text')
                  custom_value = user.custom_values.build(:custom_field => custom_field).save!
                  get :show, :params => {:id => 2}
                  assert_response :success
                end
                def test_show_inactive
                  @request.session[:user_id] = nil
                  get :show, :params => {:id => 5}
                  assert_response 404
                end
                def test_show_inactive_by_admin
                  @request.session[:user_id] = 1
                  get :show, :params => {:id => 5}
                  assert_response 200
                  assert_select 'h2', :text => /Dave2 Lopper2/
                end
                def test_show_user_who_is_not_visible_should_return_404
                  Role.anonymous.update! :users_visibility => 'members_of_visible_projects'
                  user = User.generate!
                  @request.session[:user_id] = nil
                  get :show, :params => {:id => user.id}
                  assert_response 404
                end
                def test_show_displays_memberships_based_on_project_visibility
                  @request.session[:user_id] = 1
                  get :show, :params => {:id => 2}
                  assert_response :success
                  # membership of private project admin can see
                  assert_select 'li a', :text => "OnlineStore"
                end
                def test_show_current_should_require_authentication
                  @request.session[:user_id] = nil
                  get :show, :params => {:id => 'current'}
                  assert_response 302
                end
                def test_show_current
                  @request.session[:user_id] = 2
                  get :show, :params => {:id => 'current'}
                  assert_response :success
                  assert_select 'h2', :text => /John Smith/
                end
                def test_new
                  get :new
                  assert_response :success
                  assert_select 'input[name=?]', 'user[login]'
                end
                def test_create
                  Setting.bcc_recipients = '1'
                  assert_difference 'User.count' do
                    assert_difference 'ActionMailer::Base.deliveries.size' do
                      post :create, :params => {
                        :user => {
                          :firstname => 'John',
                          :lastname => 'Doe',
                          :login => 'jdoe',
                          :password => 'secret123',
                          :password_confirmation => 'secret123',
                          :mail => 'jdoe@gmail.com',
                          :mail_notification => 'none'
                        },
                        :send_information => '1'
                      }
                    end
                  end
                  user = User.order('id DESC').first
                  assert_redirected_to :controller => 'users', :action => 'edit', :id => user.id
                  assert_equal 'John', user.firstname
                  assert_equal 'Doe', user.lastname
                  assert_equal 'jdoe', user.login
                  assert_equal 'jdoe@gmail.com', user.mail
                  assert_equal 'none', user.mail_notification
                  assert user.check_password?('secret123')
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  assert_equal [user.mail], mail.bcc
                  assert_mail_body_match 'secret', mail
                end
                def test_create_with_preferences
                  assert_difference 'User.count' do
                    post :create, :params => {
                      :user => {
                        :firstname => 'John',
                        :lastname => 'Doe',
                        :login => 'jdoe',
                        :password => 'secret123',
                        :password_confirmation => 'secret123',
                        :mail => 'jdoe@gmail.com',
                        :mail_notification => 'none'
                      },
                      :pref => {
                        'hide_mail' => '1',
                        'time_zone' => 'Paris',
                        'comments_sorting' => 'desc',
                        'warn_on_leaving_unsaved' => '0',
                        'textarea_font' => 'proportional'
                      }
                    }
                  end
                  user = User.order('id DESC').first
                  assert_equal 'jdoe', user.login
                  assert_equal true, user.pref.hide_mail
                  assert_equal 'Paris', user.pref.time_zone
                  assert_equal 'desc', user.pref[:comments_sorting]
                  assert_equal '0', user.pref[:warn_on_leaving_unsaved]
                  assert_equal 'proportional', user.pref[:textarea_font]
                end
                def test_create_with_generate_password_should_email_the_password
                  assert_difference 'User.count' do
                    post :create, :params => {
                      :user => {
                        :login => 'randompass',
                        :firstname => 'Random',
                        :lastname => 'Pass',
                        :mail => 'randompass@example.net',
                        :language => 'en',
                        :generate_password => '1',
                        :password => '',
                        :password_confirmation => ''
                      },
                      :send_information => 1
                    }
                  end
                  user = User.order('id DESC').first
                  assert_equal 'randompass', user.login
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  m = mail_body(mail).match(/Password: ([a-zA-Z0-9]+)/)
                  assert m
                  password = m[1]
                  assert user.check_password?(password)
                end
                def test_create_and_continue
                  post :create, :params => {
                    :user => {
                      :login => 'randompass',
                      :firstname => 'Random',
                      :lastname => 'Pass',
                      :mail => 'randompass@example.net',
                      :generate_password => '1'
                    },
                    :continue => '1'
                  }
                  assert_redirected_to '/users/new?user%5Bgenerate_password%5D=1'
                end
                def test_create_with_failure
                  assert_no_difference 'User.count' do
                    post :create, :params => {:user => {}}
                  end
                  assert_response :success
                  assert_select_error /Email cannot be blank/
                end
                def test_create_with_failure_sould_preserve_preference
                  assert_no_difference 'User.count' do
                    post :create, :params => {
                      :user => {},
                      :pref => {
                        'no_self_notified' => '1',
                        'hide_mail' => '1',
                        'time_zone' => 'Paris',
                        'comments_sorting' => 'desc',
                        'warn_on_leaving_unsaved' => '0'
                      }
                    }
                  end
                  assert_response :success
                  assert_select 'select#pref_time_zone option[selected=selected]', :text => /Paris/
                  assert_select 'input#pref_no_self_notified[value="1"][checked=checked]'
                end
                def test_create_admin_should_send_security_notification
                  ActionMailer::Base.deliveries.clear
                  post :create, :params => {
                    :user => {
                      :firstname => 'Edgar',
                      :lastname => 'Schmoe',
                      :login => 'eschmoe',
                      :password => 'secret123',
                      :password_confirmation => 'secret123',
                      :mail => 'eschmoe@example.foo',
                      :admin => '1'
                    }
                  }
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match '0.0.0.0', mail
                  assert_mail_body_match I18n.t(:mail_body_security_notification_add, field: I18n.t(:field_admin), value: 'eschmoe'), mail
                  assert_select_email do
                    assert_select 'a[href^=?]', 'http://localhost:3000/users', :text => 'Users'
                  end
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                end
                def test_create_non_admin_should_not_send_security_notification
                  ActionMailer::Base.deliveries.clear
                  post :create, :params => {
                    :user => {
                      :firstname => 'Edgar',
                      :lastname => 'Schmoe',
                      :login => 'eschmoe',
                      :password => 'secret123',
                      :password_confirmation => 'secret123',
                      :mail => 'eschmoe@example.foo',
                      :admin => '0'
                    }
                  }
                  assert_nil ActionMailer::Base.deliveries.last
                end
                def test_edit
                  get :edit, :params => {:id => 2}
                  assert_response :success
                  assert_select 'input[name=?][value=?]', 'user[login]', 'jsmith'
                end
                def test_edit_registered_user
                  assert User.find(2).register!
                  get :edit, :params => {:id => 2}
                  assert_response :success
                  assert_select 'a', :text => 'Activate'
                end
                def test_update
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => 2,
                    :user => {:firstname => 'Changed', :mail_notification => 'only_assigned'},
                    :pref => {:hide_mail => '1', :comments_sorting => 'desc'}
                  }
                  user = User.find(2)
                  assert_equal 'Changed', user.firstname
                  assert_equal 'only_assigned', user.mail_notification
                  assert_equal true, user.pref[:hide_mail]
                  assert_equal 'desc', user.pref[:comments_sorting]
                  assert ActionMailer::Base.deliveries.empty?
                end
                def test_update_with_failure
                  assert_no_difference 'User.count' do
                    put :update, :params => {
                      :id => 2,
                      :user => {:firstname => ''}
                    }
                  end
                  assert_response :success
                  assert_select_error /First name cannot be blank/
                end
                def test_update_with_group_ids_should_assign_groups
                  put :update, :params => {
                    :id => 2,
                    :user => {:group_ids => ['10']}
                  }
                  user = User.find(2)
                  assert_equal [10], user.group_ids
                end
                def test_update_with_activation_should_send_a_notification
                  u = User.new(:firstname => 'Foo', :lastname => 'Bar', :mail => 'foo.bar@somenet.foo', :language => 'fr')
                  u.login = 'foo'
                  u.status = User::STATUS_REGISTERED
                  u.save!
                  ActionMailer::Base.deliveries.clear
                  Setting.bcc_recipients = '1'
                  put :update, :params => {
                    :id => u.id,
                    :user => {:status => User::STATUS_ACTIVE}
                  }
                  assert u.reload.active?
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  assert_equal ['foo.bar@somenet.foo'], mail.bcc
                  assert_mail_body_match ll('fr', :notice_account_activated), mail
                end
                def test_update_with_password_change_should_send_a_notification
                  ActionMailer::Base.deliveries.clear
                  Setting.bcc_recipients = '1'
                  put :update, :params => {
                    :id => 2,
                    :user => {:password => 'newpass123', :password_confirmation => 'newpass123'},
                    :send_information => '1'
                  }
                  u = User.find(2)
                  assert u.check_password?('newpass123')
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  assert_equal [u.mail], mail.bcc
                  assert_mail_body_match 'newpass123', mail
                end
                def test_update_with_generate_password_should_email_the_password
                  ActionMailer::Base.deliveries.clear
                  Setting.bcc_recipients = '1'
                  put :update, :params => {
                    :id => 2,
                    :user => {
                      :generate_password => '1',
                      :password => '',
                      :password_confirmation => ''
                    },
                    :send_information => '1'
                  }
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  m = mail_body(mail).match(/Password: ([a-zA-Z0-9]+)/)
                  assert m
                  password = m[1]
                  assert User.find(2).check_password?(password)
                end
                def test_update_without_generate_password_should_not_change_password
                  put :update, :params => {
                    :id => 2, :user => {
                      :firstname => 'changed',
                      :generate_password => '0',
                      :password => '',
                      :password_confirmation => ''
                    },
                    :send_information => '1'
                  }
                  user = User.find(2)
                  assert_equal 'changed', user.firstname
                  assert user.check_password?('jsmith')
                end
                def test_update_user_switchin_from_auth_source_to_password_authentication
                  # Configure as auth source
                  u = User.find(2)
                  u.auth_source = AuthSource.find(1)
                  u.save!
                  put :update, :params => {
                    :id => u.id,
                    :user => {:auth_source_id => '', :password => 'newpass123', :password_confirmation => 'newpass123'}
                  }
-                 assert_equal nil, u.reload.auth_source
+                 assert_nil u.reload.auth_source
                  assert u.check_password?('newpass123')
                end
                def test_update_notified_project
                  get :edit, :params => {:id => 2}
                  assert_response :success
                  u = User.find(2)
                  assert_equal [1, 2, 5], u.projects.collect{|p| p.id}.sort
                  assert_equal [1, 2, 5], u.notified_projects_ids.sort
                  assert_select 'input[name=?][value=?]', 'user[notified_project_ids][]', '1'
                  assert_equal 'all', u.mail_notification
                  put :update, :params => {
                    :id => 2,
                    :user => {
                      :mail_notification => 'selected',
                      :notified_project_ids => [1, 2]
                    }
                  }
                  u = User.find(2)
                  assert_equal 'selected', u.mail_notification
                  assert_equal [1, 2], u.notified_projects_ids.sort
                end
                def test_update_status_should_not_update_attributes
                  user = User.find(2)
                  user.pref[:no_self_notified] = '1'
                  user.pref.save
                  put :update, :params => {
                    :id => 2,
                    :user => {:status => 3}
                  }
                  assert_response 302
                  user = User.find(2)
                  assert_equal 3, user.status
                  assert_equal '1', user.pref[:no_self_notified]
                end
                def test_update_assign_admin_should_send_security_notification
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => 2,
                    :user => {:admin => 1}
                  }
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match I18n.t(:mail_body_security_notification_add, field: I18n.t(:field_admin), value: User.find(2).login), mail
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                end
                def test_update_unassign_admin_should_send_security_notification
                  user = User.find(2)
                  user.admin = true
                  user.save!
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => user.id,
                    :user => {:admin => 0}
                  }
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match I18n.t(:mail_body_security_notification_remove, field: I18n.t(:field_admin), value: user.login), mail
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                end
                def test_update_lock_admin_should_send_security_notification
                  user = User.find(2)
                  user.admin = true
                  user.save!
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => 2,
                    :user => {:status => Principal::STATUS_LOCKED}
                  }
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match I18n.t(:mail_body_security_notification_remove, field: I18n.t(:field_admin), value: User.find(2).login), mail
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                  # if user is already locked, destroying should not send a second mail
                  # (for active admins see furtherbelow)
                  ActionMailer::Base.deliveries.clear
                  delete :destroy, :params => {:id => 1}
                  assert_nil ActionMailer::Base.deliveries.last
                end
                def test_update_unlock_admin_should_send_security_notification
                  user = User.find(5) # already locked
                  user.admin = true
                  user.save!
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => user.id,
                    :user => {:status => Principal::STATUS_ACTIVE}
                  }
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match I18n.t(:mail_body_security_notification_add, field: I18n.t(:field_admin), value: user.login), mail
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                end
                def test_update_admin_unrelated_property_should_not_send_security_notification
                  ActionMailer::Base.deliveries.clear
                  put :update, :params => {
                    :id => 1,
                    :user => {:firstname => 'Jimmy'}
                  }
                  assert_nil ActionMailer::Base.deliveries.last
                end
                def test_destroy
                  assert_difference 'User.count', -1 do
                    delete :destroy, :params => {:id => 2}
                  end
                  assert_redirected_to '/users'
                  assert_nil User.find_by_id(2)
                end
                def test_destroy_should_be_denied_for_non_admin_users
                  @request.session[:user_id] = 3
                  assert_no_difference 'User.count' do
                    get :destroy, :params => {:id => 2}
                  end
                  assert_response 403
                end
                def test_destroy_should_redirect_to_back_url_param
                  assert_difference 'User.count', -1 do
                    delete :destroy, :params => {:id => 2, :back_url => '/users?name=foo'}
                  end
                  assert_redirected_to '/users?name=foo'
                end
                def test_destroy_active_admin_should_send_security_notification
                  user = User.find(2)
                  user.admin = true
                  user.save!
                  ActionMailer::Base.deliveries.clear
                  delete :destroy, :params => {:id => user.id}
                  assert_not_nil (mail = ActionMailer::Base.deliveries.last)
                  assert_mail_body_match I18n.t(:mail_body_security_notification_remove, field: I18n.t(:field_admin), value: user.login), mail
                  # All admins should receive this
                  User.where(admin: true, status: Principal::STATUS_ACTIVE).each do |admin|
                    assert_not_nil ActionMailer::Base.deliveries.detect{|mail| [mail.bcc, mail.cc].flatten.include?(admin.mail) }
                  end
                end
              end

test/integration/admin_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 AdminTest < Redmine::IntegrationTest
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :enumerations, :users, :issue_categories,
                         :projects_trackers,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules
                def test_add_user
                  log_user("admin", "admin")
                  get "/users/new"
                  assert_response :success
                  post "/users",
                       :user => { :login => "psmith", :firstname => "Paul",
                                  :lastname => "Smith", :mail => "psmith@somenet.foo",
                                  :language => "en", :password => "psmith09",
                                  :password_confirmation => "psmith09" }
                  user = User.find_by_login("psmith")
                  assert_kind_of User, user
                  assert_redirected_to "/users/#{ user.id }/edit"
                  logged_user = User.try_to_login("psmith", "psmith09")
                  assert_kind_of User, logged_user
                  assert_equal "Paul", logged_user.firstname
                  put "/users/#{user.id}", :id => user.id, :user => { :status => User::STATUS_LOCKED }
                  assert_redirected_to "/users/#{ user.id }/edit"
                  locked_user = User.try_to_login("psmith", "psmith09")
-                 assert_equal nil, locked_user
+                 assert_nil locked_user
                end
                test "Add a user as an anonymous user should fail" do
                  post '/users',
                       :user => { :login => 'psmith', :firstname => 'Paul'},
                       :password => "psmith09", :password_confirmation => "psmith09"
                  assert_response :redirect
                  assert_redirected_to "/login?back_url=http%3A%2F%2Fwww.example.com%2Fusers"
                end
              end

test/integration/api_test/issues_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 Redmine::ApiTest::IssuesTest < Redmine::ApiTest::Base
                fixtures :projects,
                  :users,
                  :roles,
                  :members,
                  :member_roles,
                  :issues,
                  :issue_statuses,
                  :issue_relations,
                  :versions,
                  :trackers,
                  :projects_trackers,
                  :issue_categories,
                  :enabled_modules,
                  :enumerations,
                  :attachments,
                  :workflows,
                  :custom_fields,
                  :custom_values,
                  :custom_fields_projects,
                  :custom_fields_trackers,
                  :time_entries,
                  :journals,
                  :journal_details,
                  :queries,
                  :attachments
                test "GET /issues.xml should contain metadata" do
                  get '/issues.xml'
                  assert_select 'issues[type=array][total_count][limit="25"][offset="0"]'
                end
                test "GET /issues.xml with nometa param should not contain metadata" do
                  get '/issues.xml?nometa=1'
                  assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'
                end
                test "GET /issues.xml with nometa header should not contain metadata" do
                  get '/issues.xml', {}, {'X-Redmine-Nometa' => '1'}
                  assert_select 'issues[type=array]:not([total_count]):not([limit]):not([offset])'
                end
                test "GET /issues.xml with offset and limit" do
                  get '/issues.xml?offset=2&limit=3'
                  assert_select 'issues[type=array][total_count][limit="3"][offset="2"]'
                  assert_select 'issues issue', 3
                end
                test "GET /issues.xml with relations" do
                  get '/issues.xml?include=relations'
                  assert_response :success
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'issue id', :text => '3' do
                    assert_select '~ relations relation', 1
                    assert_select '~ relations relation[id="2"][issue_id="2"][issue_to_id="3"][relation_type=relates]'
                  end
                  assert_select 'issue id', :text => '1' do
                    assert_select '~ relations'
                    assert_select '~ relations relation', 0
                  end
                end
                test "GET /issues.xml with invalid query params" do
                  get '/issues.xml', {:f => ['start_date'], :op => {:start_date => '='}}
                  assert_response :unprocessable_entity
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'errors error', :text => "Start date cannot be blank"
                end
                test "GET /issues.xml with custom field filter" do
                  get '/issues.xml',
                    {:set_filter => 1, :f => ['cf_1'], :op => {:cf_1 => '='}, :v => {:cf_1 => ['MySQL']}}
                  expected_ids = Issue.visible.
                      joins(:custom_values).
                      where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
                  assert expected_ids.any?
                  assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                     ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                  end
                end
                test "GET /issues.xml with custom field filter (shorthand method)" do
                  get '/issues.xml', {:cf_1 => 'MySQL'}
                  expected_ids = Issue.visible.
                      joins(:custom_values).
                      where(:custom_values => {:custom_field_id => 1, :value => 'MySQL'}).map(&:id)
                  assert expected_ids.any?
                  assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                    ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                  end
                end
                def test_index_should_include_issue_attributes
                  get '/issues.xml'
                  assert_select 'issues>issue>is_private', :text => 'false'
                end
                def test_index_should_allow_timestamp_filtering
                  Issue.delete_all
                  Issue.generate!(:subject => '1').update_column(:updated_on, Time.parse("2014-01-02T10:25:00Z"))
                  Issue.generate!(:subject => '2').update_column(:updated_on, Time.parse("2014-01-02T12:13:00Z"))
                  get '/issues.xml',
                    {:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '<='},
                     :v => {:updated_on => ['2014-01-02T12:00:00Z']}}
                  assert_select 'issues>issue', :count => 1
                  assert_select 'issues>issue>subject', :text => '1'
                  get '/issues.xml',
                    {:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '>='},
                     :v => {:updated_on => ['2014-01-02T12:00:00Z']}}
                  assert_select 'issues>issue', :count => 1
                  assert_select 'issues>issue>subject', :text => '2'
                  get '/issues.xml',
                    {:set_filter => 1, :f => ['updated_on'], :op => {:updated_on => '>='},
                     :v => {:updated_on => ['2014-01-02T08:00:00Z']}}
                  assert_select 'issues>issue', :count => 2
                end
                test "GET /issues.xml with filter" do
                  get '/issues.xml?status_id=5'
                  expected_ids = Issue.visible.where(:status_id => 5).map(&:id)
                  assert expected_ids.any?
                  assert_select 'issues > issue > id', :count => expected_ids.count do |ids|
                     ids.each { |id| assert expected_ids.delete(id.children.first.content.to_i) }
                  end
                end
                test "GET /issues.json with filter" do
                  get '/issues.json?status_id=5'
                  json = ActiveSupport::JSON.decode(response.body)
                  status_ids_used = json['issues'].collect {|j| j['status']['id'] }
                  assert_equal 3, status_ids_used.length
                  assert status_ids_used.all? {|id| id == 5 }
                end
                test "GET /issues/:id.xml with journals" do
                  Journal.find(2).update_attribute(:private_notes, true)
                  get '/issues/1.xml?include=journals', {}, credentials('jsmith')
                  assert_select 'issue journals[type=array]' do
                    assert_select 'journal[id="1"]' do
                      assert_select 'private_notes', :text => 'false'
                      assert_select 'details[type=array]' do
                        assert_select 'detail[name=status_id]' do
                          assert_select 'old_value', :text => '1'
                          assert_select 'new_value', :text => '2'
                        end
                      end
                    end
                    assert_select 'journal[id="2"]' do
                      assert_select 'private_notes', :text => 'true'
                      assert_select 'details[type=array]'
                    end
                  end
                end
                test "GET /issues/:id.xml with journals should format timestamps in ISO 8601" do
                  get '/issues/1.xml?include=journals'
                  iso_date = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/
                  assert_select 'issue>created_on', :text => iso_date
                  assert_select 'issue>updated_on', :text => iso_date
                  assert_select 'issue journal>created_on', :text => iso_date
                end
                test "GET /issues/:id.xml with custom fields" do
                  get '/issues/3.xml'
                  assert_select 'issue custom_fields[type=array]' do
                    assert_select 'custom_field[id="1"]' do
                      assert_select 'value', :text => 'MySQL'
                    end
                  end
                  assert_nothing_raised do
                    Hash.from_xml(response.body).to_xml
                  end
                end
                test "GET /issues/:id.xml with multi custom fields" do
                  field = CustomField.find(1)
                  field.update_attribute :multiple, true
                  issue = Issue.find(3)
                  issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                  issue.save!
                  get '/issues/3.xml'
                  assert_response :success
                  assert_select 'issue custom_fields[type=array]' do
                    assert_select 'custom_field[id="1"]' do
                      assert_select 'value[type=array] value', 2
                    end
                  end
                  xml = Hash.from_xml(response.body)
                  custom_fields = xml['issue']['custom_fields']
                  assert_kind_of Array, custom_fields
                  field = custom_fields.detect {|f| f['id'] == '1'}
                  assert_kind_of Hash, field
                  assert_equal ['MySQL', 'Oracle'], field['value'].sort
                end
                test "GET /issues/:id.json with multi custom fields" do
                  field = CustomField.find(1)
                  field.update_attribute :multiple, true
                  issue = Issue.find(3)
                  issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                  issue.save!
                  get '/issues/3.json'
                  assert_response :success
                  json = ActiveSupport::JSON.decode(response.body)
                  custom_fields = json['issue']['custom_fields']
                  assert_kind_of Array, custom_fields
                  field = custom_fields.detect {|f| f['id'] == 1}
                  assert_kind_of Hash, field
                  assert_equal ['MySQL', 'Oracle'], field['value'].sort
                end
                test "GET /issues/:id.xml with empty value for multi custom field" do
                  field = CustomField.find(1)
                  field.update_attribute :multiple, true
                  issue = Issue.find(3)
                  issue.custom_field_values = {1 => ['']}
                  issue.save!
                  get '/issues/3.xml'
                  assert_select 'issue custom_fields[type=array]' do
                    assert_select 'custom_field[id="1"]' do
                      assert_select 'value[type=array]:empty'
                    end
                  end
                  xml = Hash.from_xml(response.body)
                  custom_fields = xml['issue']['custom_fields']
                  assert_kind_of Array, custom_fields
                  field = custom_fields.detect {|f| f['id'] == '1'}
                  assert_kind_of Hash, field
                  assert_equal [], field['value']
                end
                test "GET /issues/:id.json with empty value for multi custom field" do
                  field = CustomField.find(1)
                  field.update_attribute :multiple, true
                  issue = Issue.find(3)
                  issue.custom_field_values = {1 => ['']}
                  issue.save!
                  get '/issues/3.json'
                  assert_response :success
                  json = ActiveSupport::JSON.decode(response.body)
                  custom_fields = json['issue']['custom_fields']
                  assert_kind_of Array, custom_fields
                  field = custom_fields.detect {|f| f['id'] == 1}
                  assert_kind_of Hash, field
                  assert_equal [], field['value'].sort
                end
                test "GET /issues/:id.xml with attachments" do
                  get '/issues/3.xml?include=attachments'
                  assert_select 'issue attachments[type=array]' do
                    assert_select 'attachment', 4
                    assert_select 'attachment id', :text => '1' do
                      assert_select '~ filename', :text => 'error281.txt'
                      assert_select '~ content_url', :text => 'http://www.example.com/attachments/download/1/error281.txt'
                    end
                  end
                end
                test "GET /issues/:id.xml with subtasks" do
                  issue = Issue.generate_with_descendants!(:project_id => 1)
                  get "/issues/#{issue.id}.xml?include=children"
                  assert_select 'issue id', :text => issue.id.to_s do
                    assert_select '~ children[type=array] > issue', 2
                    assert_select '~ children[type=array] > issue > children', 1
                  end
                end
                test "GET /issues/:id.json with subtasks" do
                  issue = Issue.generate_with_descendants!(:project_id => 1)
                  get "/issues/#{issue.id}.json?include=children"
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_equal 2, json['issue']['children'].size
                  assert_equal 1, json['issue']['children'].select {|child| child.key?('children')}.size
                end
                def test_show_should_include_issue_attributes
                  get '/issues/1.xml'
                  assert_select 'issue>is_private', :text => 'false'
                end
                test "GET /issues/:id.xml?include=watchers should include watchers" do
                  Watcher.create!(:user_id => 3, :watchable => Issue.find(1))
                  get '/issues/1.xml?include=watchers', {}, credentials('jsmith')
                  assert_response :ok
                  assert_equal 'application/xml', response.content_type
                  assert_select 'issue' do
                    assert_select 'watchers', Issue.find(1).watchers.count
                    assert_select 'watchers' do
                      assert_select 'user[id="3"]'
                    end
                  end
                end
                test "GET /issues/:id.xml should not disclose associated changesets from projects the user has no access to" do
                  project = Project.generate!(:is_public => false)
                  repository = Repository::Subversion.create!(:project => project, :url => "svn://localhost")
                  Issue.find(1).changesets << Changeset.generate!(:repository => repository)
                  assert Issue.find(1).changesets.any?
                  get '/issues/1.xml?include=changesets', {}, credentials('jsmith')
                  # the user jsmith has no permission to view the associated changeset
                  assert_select 'issue changesets[type=array]' do
                    assert_select 'changeset', 0
                  end
                end
                test "GET /issues/:id.xml should contains total_estimated_hours and total_spent_hours" do
                  parent = Issue.find(3)
                  child = Issue.generate!(:parent_issue_id => parent.id, :estimated_hours => 3.0)
                  TimeEntry.create!(:project => child.project, :issue => child, :user => child.author, :spent_on => child.author.today,
                                    :hours => '2.5', :comments => '', :activity_id => TimeEntryActivity.first.id)
                  get '/issues/3.xml'
                  assert_equal 'application/xml', response.content_type
                  assert_select 'issue' do
                    assert_select 'estimated_hours',       parent.estimated_hours.to_s
                    assert_select 'total_estimated_hours', (parent.estimated_hours.to_f + 3.0).to_s
                    assert_select 'spent_hours',           parent.spent_hours.to_s
                    assert_select 'total_spent_hours',     (parent.spent_hours.to_f + 2.5).to_s
                  end
                end
                test "GET /issues/:id.xml should contains total_estimated_hours, and should not contains spent_hours and total_spent_hours when permission does not exists" do
                  parent = Issue.find(3)
                  child = Issue.generate!(:parent_issue_id => parent.id, :estimated_hours => 3.0)
                  # remove permission!
                  Role.anonymous.remove_permission! :view_time_entries
                  #Role.all.each { |role| role.remove_permission! :view_time_entries }
                  get '/issues/3.xml'
                  assert_equal 'application/xml', response.content_type
                  assert_select 'issue' do
                    assert_select 'estimated_hours',       parent.estimated_hours.to_s
                    assert_select 'total_estimated_hours', (parent.estimated_hours.to_f + 3.0).to_s
                    assert_select 'spent_hours',           false
                    assert_select 'total_spent_hours',     false
                  end
                end
                test "GET /issues/:id.json should contains total_estimated_hours and total_spent_hours" do
                  parent = Issue.find(3)
                  child = Issue.generate!(:parent_issue_id => parent.id, :estimated_hours => 3.0)
                  TimeEntry.create!(:project => child.project, :issue => child, :user => child.author, :spent_on => child.author.today,
                                    :hours => '2.5', :comments => '', :activity_id => TimeEntryActivity.first.id)
                  get '/issues/3.json'
                  assert_equal 'application/json', response.content_type
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_equal parent.estimated_hours, json['issue']['estimated_hours']
                  assert_equal (parent.estimated_hours.to_f + 3.0), json['issue']['total_estimated_hours']
                  assert_equal parent.spent_hours, json['issue']['spent_hours']
                  assert_equal (parent.spent_hours.to_f + 2.5), json['issue']['total_spent_hours']
                end
                test "GET /issues/:id.json should contains total_estimated_hours, and should not contains spent_hours and total_spent_hours when permission does not exists" do
                  parent = Issue.find(3)
                  child = Issue.generate!(:parent_issue_id => parent.id, :estimated_hours => 3.0)
                  # remove permission!
                  Role.anonymous.remove_permission! :view_time_entries
                  #Role.all.each { |role| role.remove_permission! :view_time_entries }
                  get '/issues/3.json'
                  assert_equal 'application/json', response.content_type
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_equal parent.estimated_hours, json['issue']['estimated_hours']
                  assert_equal (parent.estimated_hours.to_f + 3.0), json['issue']['total_estimated_hours']
-                 assert_equal nil, json['issue']['spent_hours']
-                 assert_equal nil, json['issue']['total_spent_hours']
+                 assert_nil json['issue']['spent_hours']
+                 assert_nil json['issue']['total_spent_hours']
                end
                test "POST /issues.xml should create an issue with the attributes" do
              payload = <<-XML
              <?xml version="1.0" encoding="UTF-8" ?>
              <issue>
                <project_id>1</project_id>
                <tracker_id>2</tracker_id>
                <status_id>3</status_id>
                <subject>API test</subject>
              </issue>
              XML
                  assert_difference('Issue.count') do
                    post '/issues.xml', payload, {"CONTENT_TYPE" => 'application/xml'}.merge(credentials('jsmith'))
                  end
                  issue = Issue.order('id DESC').first
                  assert_equal 1, issue.project_id
                  assert_equal 2, issue.tracker_id
                  assert_equal 3, issue.status_id
                  assert_equal 'API test', issue.subject
                  assert_response :created
                  assert_equal 'application/xml', @response.content_type
                  assert_select 'issue > id', :text => issue.id.to_s
                end
                test "POST /issues.xml with watcher_user_ids should create issue with watchers" do
                  assert_difference('Issue.count') do
                    post '/issues.xml',
                         {:issue => {:project_id => 1, :subject => 'Watchers',
                          :tracker_id => 2, :status_id => 3, :watcher_user_ids => [3, 1]}}, credentials('jsmith')
                    assert_response :created
                  end
                  issue = Issue.order('id desc').first
                  assert_equal 2, issue.watchers.size
                  assert_equal [1, 3], issue.watcher_user_ids.sort
                end
                test "POST /issues.xml with failure should return errors" do
                  assert_no_difference('Issue.count') do
                    post '/issues.xml', {:issue => {:project_id => 1}}, credentials('jsmith')
                  end
                  assert_select 'errors error', :text => "Subject cannot be blank"
                end
                test "POST /issues.json should create an issue with the attributes" do
              payload = <<-JSON
              {
                "issue": {
                  "project_id": "1",
                  "tracker_id": "2",
                  "status_id": "3",
                  "subject": "API test"
                }
              }
              JSON
                  assert_difference('Issue.count') do
                    post '/issues.json', payload, {"CONTENT_TYPE" => 'application/json'}.merge(credentials('jsmith'))
                  end
                  issue = Issue.order('id DESC').first
                  assert_equal 1, issue.project_id
                  assert_equal 2, issue.tracker_id
                  assert_equal 3, issue.status_id
                  assert_equal 'API test', issue.subject
                end
                test "POST /issues.json should accept project identifier as project_id" do
                  assert_difference('Issue.count') do
                    post '/issues.json',
                      {:issue => {:project_id => 'subproject1', :tracker_id => 2, :subject => 'Foo'}},
                      credentials('jsmith')
                    assert_response :created
                  end
                end
                test "POST /issues.json without tracker_id should accept custom fields" do
                  field = IssueCustomField.generate!(
                    :field_format => 'list',
                    :multiple => true,
                    :possible_values => ["V1", "V2", "V3"],
                    :default_value => "V2",
                    :is_for_all => true,
                    :trackers => Tracker.all.to_a
                  )
              payload = <<-JSON
              {
                "issue": {
                  "project_id": "1",
                  "subject": "Multivalued custom field",
                  "custom_field_values":{"#{field.id}":["V1","V3"]}
                }
              }
              JSON
                  assert_difference('Issue.count') do
                    post '/issues.json', payload, {"CONTENT_TYPE" => 'application/json'}.merge(credentials('jsmith'))
                  end
                  assert_response :created
                  issue = Issue.order('id DESC').first
                  assert_equal ["V1", "V3"], issue.custom_field_value(field).sort
                end
                test "POST /issues.json with omitted custom field should set default value" do
                  field = IssueCustomField.generate!(:default_value => "Default")
                  issue = new_record(Issue) do
                    post '/issues.json',
                      {:issue => {:project_id => 1, :subject => 'API', :custom_field_values => {}}},
                      credentials('jsmith')
                  end
                  assert_equal "Default", issue.custom_field_value(field)
                end
                test "POST /issues.json with custom field set to blank should not set default value" do
                  field = IssueCustomField.generate!(:default_value => "Default")
                  issue = new_record(Issue) do
                    post '/issues.json',
                      {:issue => {:project_id => 1, :subject => 'API', :custom_field_values => {field.id.to_s => ""}}},
                      credentials('jsmith')
                  end
                  assert_equal "", issue.custom_field_value(field)
                end
                test "POST /issues.json with failure should return errors" do
                  assert_no_difference('Issue.count') do
                    post '/issues.json', {:issue => {:project_id => 1}}, credentials('jsmith')
                  end
                  json = ActiveSupport::JSON.decode(response.body)
                  assert json['errors'].include?("Subject cannot be blank")
                end
                test "POST /issues.json with invalid project_id should respond with 422" do
                  post '/issues.json', {:issue => {:project_id => 999, :subject => "API"}}, credentials('jsmith')
                  assert_response 422
                end
                test "PUT /issues/:id.xml" do
                  assert_difference('Journal.count') do
                    put '/issues/6.xml',
                      {:issue => {:subject => 'API update', :notes => 'A new note'}},
                      credentials('jsmith')
                  end
                  issue = Issue.find(6)
                  assert_equal "API update", issue.subject
                  journal = Journal.last
                  assert_equal "A new note", journal.notes
                end
                test "PUT /issues/:id.xml with custom fields" do
                  put '/issues/3.xml',
                    {:issue => {:custom_fields => [
                      {'id' => '1', 'value' => 'PostgreSQL' },
                      {'id' => '2', 'value' => '150'}
                      ]}},
                    credentials('jsmith')
                  issue = Issue.find(3)
                  assert_equal '150', issue.custom_value_for(2).value
                  assert_equal 'PostgreSQL', issue.custom_value_for(1).value
                end
                test "PUT /issues/:id.xml with multi custom fields" do
                  field = CustomField.find(1)
                  field.update_attribute :multiple, true
                  put '/issues/3.xml',
                    {:issue => {:custom_fields => [
                      {'id' => '1', 'value' => ['MySQL', 'PostgreSQL'] },
                      {'id' => '2', 'value' => '150'}
                      ]}},
                    credentials('jsmith')
                  issue = Issue.find(3)
                  assert_equal '150', issue.custom_value_for(2).value
                  assert_equal ['MySQL', 'PostgreSQL'], issue.custom_field_value(1).sort
                end
                test "PUT /issues/:id.xml with project change" do
                  put '/issues/3.xml',
                    {:issue => {:project_id => 2, :subject => 'Project changed'}},
                    credentials('jsmith')
                  issue = Issue.find(3)
                  assert_equal 2, issue.project_id
                  assert_equal 'Project changed', issue.subject
                end
                test "PUT /issues/:id.xml with notes only" do
                  assert_difference('Journal.count') do
                    put '/issues/6.xml',
                      {:issue => {:notes => 'Notes only'}},
                      credentials('jsmith')
                  end
                  journal = Journal.last
                  assert_equal "Notes only", journal.notes
                end
                test "PUT /issues/:id.json with omitted custom field should not change blank value to default value" do
                  field = IssueCustomField.generate!(:default_value => "Default")
                  issue = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {field.id.to_s => ""})
                  assert_equal "", issue.reload.custom_field_value(field)
                  assert_difference('Journal.count') do
                    put "/issues/#{issue.id}.json",
                      {:issue => {:custom_field_values => {}, :notes => 'API'}},
                      credentials('jsmith')
                  end
                  assert_equal "", issue.reload.custom_field_value(field)
                end
                test "PUT /issues/:id.json with custom field set to blank should not change blank value to default value" do
                  field = IssueCustomField.generate!(:default_value => "Default")
                  issue = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {field.id.to_s => ""})
                  assert_equal "", issue.reload.custom_field_value(field)
                  assert_difference('Journal.count') do
                    put "/issues/#{issue.id}.json",
                      {:issue => {:custom_field_values => {field.id.to_s => ""}, :notes => 'API'}},
                      credentials('jsmith')
                  end
                  assert_equal "", issue.reload.custom_field_value(field)
                end
                test "PUT /issues/:id.json with tracker change and omitted custom field specific to that tracker should set default value" do
                  field = IssueCustomField.generate!(:default_value => "Default", :tracker_ids => [2])
                  issue = Issue.generate!(:project_id => 1, :tracker_id => 1)
                  assert_difference('Journal.count') do
                    put "/issues/#{issue.id}.json",
                      {:issue => {:tracker_id => 2, :custom_field_values => {}, :notes => 'API'}},
                      credentials('jsmith')
                  end
                  assert_equal 2, issue.reload.tracker_id
                  assert_equal "Default", issue.reload.custom_field_value(field)
                end
                test "PUT /issues/:id.json with tracker change and custom field specific to that tracker set to blank should not set default value" do
                  field = IssueCustomField.generate!(:default_value => "Default", :tracker_ids => [2])
                  issue = Issue.generate!(:project_id => 1, :tracker_id => 1)
                  assert_difference('Journal.count') do
                    put "/issues/#{issue.id}.json",
                      {:issue => {:tracker_id => 2, :custom_field_values => {field.id.to_s => ""}, :notes => 'API'}},
                      credentials('jsmith')
                  end
                  assert_equal 2, issue.reload.tracker_id
                  assert_equal "", issue.reload.custom_field_value(field)
                end
                test "PUT /issues/:id.xml with failed update" do
                  put '/issues/6.xml', {:issue => {:subject => ''}}, credentials('jsmith')
                  assert_response :unprocessable_entity
                  assert_select 'errors error', :text => "Subject cannot be blank"
                end
                test "PUT /issues/:id.xml with invalid assignee should return error" do
                  user = User.generate!
                  put '/issues/6.xml', {:issue => {:assigned_to_id => user.id}}, credentials('jsmith')
                  assert_response :unprocessable_entity
                  assert_select 'errors error', :text => "Assignee is invalid"
                end
                test "PUT /issues/:id.json" do
                  assert_difference('Journal.count') do
                    put '/issues/6.json',
                      {:issue => {:subject => 'API update', :notes => 'A new note'}},
                      credentials('jsmith')
                    assert_response :ok
                    assert_equal '', response.body
                  end
                  issue = Issue.find(6)
                  assert_equal "API update", issue.subject
                  journal = Journal.last
                  assert_equal "A new note", journal.notes
                end
                test "PUT /issues/:id.json with failed update" do
                  put '/issues/6.json', {:issue => {:subject => ''}}, credentials('jsmith')
                  assert_response :unprocessable_entity
                  json = ActiveSupport::JSON.decode(response.body)
                  assert json['errors'].include?("Subject cannot be blank")
                end
                test "DELETE /issues/:id.xml" do
                  assert_difference('Issue.count', -1) do
                    delete '/issues/6.xml', {}, credentials('jsmith')
                    assert_response :ok
                    assert_equal '', response.body
                  end
                  assert_nil Issue.find_by_id(6)
                end
                test "DELETE /issues/:id.json" do
                  assert_difference('Issue.count', -1) do
                    delete '/issues/6.json', {}, credentials('jsmith')
                    assert_response :ok
                    assert_equal '', response.body
                  end
                  assert_nil Issue.find_by_id(6)
                end
                test "POST /issues/:id/watchers.xml should add watcher" do
                  assert_difference 'Watcher.count' do
                    post '/issues/1/watchers.xml', {:user_id => 3}, credentials('jsmith')
                    assert_response :ok
                    assert_equal '', response.body
                  end
                  watcher = Watcher.order('id desc').first
                  assert_equal Issue.find(1), watcher.watchable
                  assert_equal User.find(3), watcher.user
                end
                test "DELETE /issues/:id/watchers/:user_id.xml should remove watcher" do
                  Watcher.create!(:user_id => 3, :watchable => Issue.find(1))
                  assert_difference 'Watcher.count', -1 do
                    delete '/issues/1/watchers/3.xml', {}, credentials('jsmith')
                    assert_response :ok
                    assert_equal '', response.body
                  end
                  assert_equal false, Issue.find(1).watched_by?(User.find(3))
                end
                def test_create_issue_with_uploaded_file
                  token = xml_upload('test_create_with_upload', credentials('jsmith'))
                  attachment = Attachment.find_by_token(token)
                  # create the issue with the upload's token
                  assert_difference 'Issue.count' do
                    post '/issues.xml',
                         {:issue => {:project_id => 1, :subject => 'Uploaded file',
                                     :uploads => [{:token => token, :filename => 'test.txt',
                                                   :content_type => 'text/plain'}]}},
                         credentials('jsmith')
                    assert_response :created
                  end
                  issue = Issue.order('id DESC').first
                  assert_equal 1, issue.attachments.count
                  assert_equal attachment, issue.attachments.first
                  attachment.reload
                  assert_equal 'test.txt', attachment.filename
                  assert_equal 'text/plain', attachment.content_type
                  assert_equal 'test_create_with_upload'.size, attachment.filesize
                  assert_equal 2, attachment.author_id
                  # get the issue with its attachments
                  get "/issues/#{issue.id}.xml", :include => 'attachments'
                  assert_response :success
                  xml = Hash.from_xml(response.body)
                  attachments = xml['issue']['attachments']
                  assert_kind_of Array, attachments
                  assert_equal 1, attachments.size
                  url = attachments.first['content_url']
                  assert_not_nil url
                  # download the attachment
                  get url
                  assert_response :success
                  assert_equal 'test_create_with_upload', response.body
                end
                def test_create_issue_with_multiple_uploaded_files_as_xml
                  token1 = xml_upload('File content 1', credentials('jsmith'))
                  token2 = xml_upload('File content 2', credentials('jsmith'))
                  payload = <<-XML
              <?xml version="1.0" encoding="UTF-8" ?>
              <issue>
                <project_id>1</project_id>
                <tracker_id>1</tracker_id>
                <subject>Issue with multiple attachments</subject>
                <uploads type="array">
                  <upload>
                    <token>#{token1}</token>
                    <filename>test1.txt</filename>
                  </upload>
                  <upload>
                    <token>#{token2}</token>
                    <filename>test1.txt</filename>
                  </upload>
                </uploads>
              </issue>
              XML
                  assert_difference 'Issue.count' do
                    post '/issues.xml', payload, {"CONTENT_TYPE" => 'application/xml'}.merge(credentials('jsmith'))
                    assert_response :created
                  end
                  issue = Issue.order('id DESC').first
                  assert_equal 2, issue.attachments.count
                end
                def test_create_issue_with_multiple_uploaded_files_as_json
                  token1 = json_upload('File content 1', credentials('jsmith'))
                  token2 = json_upload('File content 2', credentials('jsmith'))
                  payload = <<-JSON
              {
                "issue": {
                  "project_id": "1",
                  "tracker_id": "1",
                  "subject": "Issue with multiple attachments",
                  "uploads": [
                    {"token": "#{token1}", "filename": "test1.txt"},
                    {"token": "#{token2}", "filename": "test2.txt"}
                  ]
                }
              }
              JSON
                  assert_difference 'Issue.count' do
                    post '/issues.json', payload, {"CONTENT_TYPE" => 'application/json'}.merge(credentials('jsmith'))
                    assert_response :created
                  end
                  issue = Issue.order('id DESC').first
                  assert_equal 2, issue.attachments.count
                end
                def test_update_issue_with_uploaded_file
                  token = xml_upload('test_upload_with_upload', credentials('jsmith'))
                  attachment = Attachment.find_by_token(token)
                  # update the issue with the upload's token
                  assert_difference 'Journal.count' do
                    put '/issues/1.xml',
                        {:issue => {:notes => 'Attachment added',
                                    :uploads => [{:token => token, :filename => 'test.txt',
                                                  :content_type => 'text/plain'}]}},
                        credentials('jsmith')
                    assert_response :ok
                    assert_equal '', @response.body
                  end
                  issue = Issue.find(1)
                  assert_include attachment, issue.attachments
                end
              end

test/unit/auth_source_ldap_test.rb +3 -3

              # Redmine - project management software
              # Copyright (C) 2006-2016  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_initialize
                  auth_source = AuthSourceLdap.new
                  assert_nil auth_source.id
                  assert_equal "AuthSourceLdap", auth_source.type
                  assert_equal "", auth_source.name
                  assert_nil auth_source.host
                  assert_nil auth_source.port
                  assert_nil auth_source.account
                  assert_equal "", auth_source.account_password
                  assert_nil auth_source.base_dn
                  assert_nil auth_source.attr_login
                  assert_nil auth_source.attr_firstname
                  assert_nil auth_source.attr_lastname
                  assert_nil auth_source.attr_mail
                  assert_equal false, auth_source.onthefly_register
                  assert_equal false, auth_source.tls
                  assert_nil auth_source.filter
                  assert_nil auth_source.timeout
                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?
                  test '#authenticate with a valid LDAP user should return the user attributes' do
                    auth = AuthSourceLdap.find(1)
                    auth.update_attribute :onthefly_register, true
                    attributes =  auth.authenticate('example1','123456')
                    assert attributes.is_a?(Hash), "An hash was not returned"
                    assert_equal 'Example', attributes[:firstname]
                    assert_equal 'One', attributes[:lastname]
                    assert_equal 'example1@redmine.org', attributes[:mail]
                    assert_equal auth.id, attributes[:auth_source_id]
                    attributes.keys.each do |attribute|
                      assert User.new.respond_to?("#{attribute}="), "Unexpected :#{attribute} attribute returned"
                    end
                  end
                  test '#authenticate with an invalid LDAP user should return nil' do
                    auth = AuthSourceLdap.find(1)
-                   assert_equal nil, auth.authenticate('nouser','123456')
+                   assert_nil auth.authenticate('nouser','123456')
                  end
                  test '#authenticate without a login should return nil' do
                    auth = AuthSourceLdap.find(1)
-                   assert_equal nil, auth.authenticate('','123456')
+                   assert_nil auth.authenticate('','123456')
                  end
                  test '#authenticate without a password should return nil' do
                    auth = AuthSourceLdap.find(1)
-                   assert_equal nil, auth.authenticate('edavis','')
+                   assert_nil auth.authenticate('edavis','')
                  end
                  test '#authenticate without filter should return any user' do
                    auth = AuthSourceLdap.find(1)
                    assert auth.authenticate('example1','123456')
                    assert auth.authenticate('edavis', '123456')
                  end
                  test '#authenticate with filter should return user who matches the filter only' do
                    auth = AuthSourceLdap.find(1)
                    auth.filter = "(mail=*@redmine.org)"
                    assert auth.authenticate('example1','123456')
                    assert_nil auth.authenticate('edavis', '123456')
                  end
                  def test_authenticate_should_timeout
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.timeout = 1
                    def auth_source.initialize_ldap_con(*args); sleep(5); end
                    assert_raise AuthSourceTimeoutException do
                      auth_source.authenticate 'example1', '123456'
                    end
                  end
                  def test_search_should_return_matching_entries
                    results = AuthSource.search("exa")
                    assert_equal 1, results.size
                    result = results.first
                    assert_kind_of Hash, result
                    assert_equal "example1", result[:login]
                    assert_equal "Example", result[:firstname]
                    assert_equal "One", result[:lastname]
                    assert_equal "example1@redmine.org", result[:mail]
                    assert_equal 1, result[:auth_source_id]
                  end
                  def test_search_with_no_match_should_return_an_empty_array
                    results = AuthSource.search("wro")
                    assert_equal [], results
                  end
                  def test_search_with_exception_should_return_an_empty_array
                    Net::LDAP.stubs(:new).raises(Net::LDAP::LdapError, 'Cannot connect')
                    results = AuthSource.search("exa")
                    assert_equal [], results
                  end
                  def test_test_connection_with_correct_host_and_port
                    auth_source = AuthSourceLdap.find(1)
                    assert_nothing_raised Net::LDAP::Error do
                      auth_source.test_connection
                    end
                  end
                  def test_test_connection_with_incorrect_host
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.host = "badhost"
                    auth_source.save!
                    assert_raise Net::LDAP::Error do
                      auth_source.test_connection
                    end
                  end
                  def test_test_connection_with_incorrect_port
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.port = 1234
                    auth_source.save!
                    assert_raise Net::LDAP::Error do
                      auth_source.test_connection
                    end
                  end
                  def test_test_connection_bind_with_account_and_password
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.account = "cn=admin,dc=redmine,dc=org"
                    auth_source.account_password = "secret"
                    auth_source.save!
                    assert_equal "cn=admin,dc=redmine,dc=org", auth_source.account
                    assert_equal "secret", auth_source.account_password
                    assert_nil auth_source.test_connection
                  end
                  def test_test_connection_bind_without_account_and_password
                    auth_source = AuthSourceLdap.find(1)
                    assert_nil auth_source.account
                    assert_equal "", auth_source.account_password
                    assert_nil auth_source.test_connection
                  end
                  def test_test_connection_bind_with_incorrect_account
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.account = "cn=baduser,dc=redmine,dc=org"
                    auth_source.account_password = "secret"
                    auth_source.save!
                    assert_equal "cn=baduser,dc=redmine,dc=org", auth_source.account
                    assert_equal "secret", auth_source.account_password
                    assert_raise AuthSourceException do
                      auth_source.test_connection
                    end
                  end
                  def test_test_connection_bind_with_incorrect_password
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.account = "cn=admin,dc=redmine,dc=org"
                    auth_source.account_password = "badpassword"
                    auth_source.save!
                    assert_equal "cn=admin,dc=redmine,dc=org", auth_source.account
                    assert_equal "badpassword", auth_source.account_password
                    assert_raise AuthSourceException do
                      auth_source.test_connection
                    end
                  end
                else
                  puts '(Test LDAP server not configured)'
                end
              end

test/unit/changeset_test.rb +1 -1

              # encoding: utf-8
              #
              # Redmine - project management software
              # Copyright (C) 2006-2016  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 ChangesetTest < ActiveSupport::TestCase
                fixtures :projects, :repositories,
                         :issues, :issue_statuses, :issue_categories,
                         :journals, :journal_details,
                         :workflows,
                         :changesets, :changes,
                         :enumerations,
                         :custom_fields, :custom_values,
                         :users, :members, :member_roles,
                         :email_addresses,
                         :trackers, :projects_trackers,
                         :enabled_modules, :roles
                def test_ref_keywords_any
                  ActionMailer::Base.deliveries.clear
                  Setting.commit_ref_keywords = '*'
                  Setting.commit_update_keywords = [{'keywords' => 'fixes , closes', 'status_id' => '5', 'done_ratio' => '90'}]
                  c = Changeset.new(:repository   => Project.find(1).repository,
                                    :committed_on => Time.now,
                                    :comments     => 'New commit (#2). Fixes #1',
                                    :revision     => '12345')
                  assert c.save
                  assert_equal [1, 2], c.issue_ids.sort
                  fixed = Issue.find(1)
                  assert fixed.closed?
                  assert_equal 90, fixed.done_ratio
                  assert_equal 1, ActionMailer::Base.deliveries.size
                end
                def test_ref_keywords
                  Setting.commit_ref_keywords = 'refs'
                  Setting.commit_update_keywords = ''
                  c = Changeset.new(:repository   => Project.find(1).repository,
                                    :committed_on => Time.now,
                                    :comments     => 'Ignores #2. Refs #1',
                                    :revision     => '12345')
                  assert c.save
                  assert_equal [1], c.issue_ids.sort
                end
                def test_ref_keywords_any_only
                  Setting.commit_ref_keywords = '*'
                  Setting.commit_update_keywords = ''
                  c = Changeset.new(:repository   => Project.find(1).repository,
                                    :committed_on => Time.now,
                                    :comments     => 'Ignores #2. Refs #1',
                                    :revision     => '12345')
                  assert c.save
                  assert_equal [1, 2], c.issue_ids.sort
                end
                def test_ref_keywords_any_with_timelog
                  Setting.commit_ref_keywords = '*'
                  Setting.commit_logtime_enabled = '1'
                  {
                    '2' => 2.0,
                    '2h' => 2.0,
                    '2hours' => 2.0,
                    '15m' => 0.25,
                    '15min' => 0.25,
                    '3h15' => 3.25,
                    '3h15m' => 3.25,
                    '3h15min' => 3.25,
                    '3:15' => 3.25,
                    '3.25' => 3.25,
                    '3.25h' => 3.25,
                    '3,25' => 3.25,
                    '3,25h' => 3.25,
                  }.each do |syntax, expected_hours|
                    c = Changeset.new(:repository   => Project.find(1).repository,
                                      :committed_on => 24.hours.ago,
                                      :comments     => "Worked on this issue #1 @#{syntax}",
                                      :revision     => '520',
                                      :user         => User.find(2))
                    assert_difference 'TimeEntry.count' do
                      c.scan_comment_for_issue_ids
                    end
                    assert_equal [1], c.issue_ids.sort
                    time = TimeEntry.order('id desc').first
                    assert_equal 1, time.issue_id
                    assert_equal 1, time.project_id
                    assert_equal 2, time.user_id
                    assert_equal expected_hours, time.hours,
                        "@#{syntax} should be logged as #{expected_hours} hours but was #{time.hours}"
                    assert_equal Date.yesterday, time.spent_on
                    assert time.activity.is_default?
                    assert time.comments.include?('r520'),
                          "r520 was expected in time_entry comments: #{time.comments}"
                  end
                end
                def test_ref_keywords_closing_with_timelog
                  Setting.commit_ref_keywords = '*'
                  Setting.commit_update_keywords = [{'keywords' => 'fixes , closes',
                                                     'status_id' => IssueStatus.where(:is_closed => true).first.id.to_s}]
                  Setting.commit_logtime_enabled = '1'
                  c = Changeset.new(:repository   => Project.find(1).repository,
                                    :committed_on => Time.now,
                                    :comments     => 'This is a comment. Fixes #1 @4.5, #2 @1',
                                    :user         => User.find(2))
                  assert_difference 'TimeEntry.count', 2 do
                    c.scan_comment_for_issue_ids
                  end
                  assert_equal [1, 2], c.issue_ids.sort
                  assert Issue.find(1).closed?
                  assert Issue.find(2).closed?
                  times = TimeEntry.order('id desc').limit(2)
                  assert_equal [1, 2], times.collect(&:issue_id).sort
                end
                def test_ref_keywords_any_line_start
                  Setting.commit_ref_keywords = '*'
                  c = Changeset.new(:repository   => Project.find(1).repository,
                                    :committed_on => Time.now,
                                    :comments     => '#1 is the reason of this commit',
                                    :revision     => '12345')
                  assert c.save
                  assert_equal [1], c.issue_ids.sort
                end
                def test_ref_keywords_allow_brackets_around_a_issue_number
                  Setting.commit_ref_keywords = '*'
                  c = Changeset.new(:repository   => Project.find(1).repository,
                                    :committed_on => Time.now,
                                    :comments     => '[#1] Worked on this issue',
                                    :revision     => '12345')
                  assert c.save
                  assert_equal [1], c.issue_ids.sort
                end
                def test_ref_keywords_allow_brackets_around_multiple_issue_numbers
                  Setting.commit_ref_keywords = '*'
                  c = Changeset.new(:repository   => Project.find(1).repository,
                                    :committed_on => Time.now,
                                    :comments     => '[#1 #2, #3] Worked on these',
                                    :revision     => '12345')
                  assert c.save
                  assert_equal [1,2,3], c.issue_ids.sort
                end
                def test_ref_keywords_with_large_number_should_not_error
                  Setting.commit_ref_keywords = '*'
                  c = Changeset.new(:repository   => Project.find(1).repository,
                                    :committed_on => Time.now,
                                    :comments     => 'Out of range #2010021810000121',
                                    :revision     => '12345')
                  assert_nothing_raised do
                    assert c.save
                  end
                  assert_equal [], c.issue_ids.sort
                end
                def test_update_keywords_with_changes_should_create_journal
                  issue = Issue.generate!(:project_id => 1, :status_id => 1)
                  with_settings :commit_update_keywords => [{'keywords' => 'fixes', 'status_id' => '3'}] do
                    assert_difference 'Journal.count' do
                      c = Changeset.generate!(:repository => Project.find(1).repository,:comments => "Fixes ##{issue.id}")
                      assert_include c.id, issue.reload.changeset_ids
                      journal = Journal.order('id DESC').first
                      assert_equal 1, journal.details.count
                    end
                  end
                end
                def test_update_keywords_without_change_should_not_create_journal
                  issue = Issue.generate!(:project_id => 1, :status_id => 3)
                  with_settings :commit_update_keywords => [{'keywords' => 'fixes', 'status_id' => '3'}] do
                    assert_no_difference 'Journal.count' do
                      c = Changeset.generate!(:repository => Project.find(1).repository,:comments => "Fixes ##{issue.id}")
                      assert_include c.id, issue.reload.changeset_ids
                    end
                  end
                end
                def test_update_keywords_with_multiple_rules
                  with_settings :commit_update_keywords => [
                    {'keywords' => 'fixes, closes', 'status_id' => '5'},
                    {'keywords' => 'resolves', 'status_id' => '3'}
                  ] do
                    issue1 = Issue.generate!
                    issue2 = Issue.generate!
                    Changeset.generate!(:comments => "Closes ##{issue1.id}\nResolves ##{issue2.id}")
                    assert_equal 5, issue1.reload.status_id
                    assert_equal 3, issue2.reload.status_id
                  end
                end
                def test_update_keywords_with_multiple_rules_for_the_same_keyword_should_match_tracker
                  with_settings :commit_update_keywords => [
                    {'keywords' => 'fixes', 'status_id' => '5', 'if_tracker_id' => '2'},
                    {'keywords' => 'fixes', 'status_id' => '3', 'if_tracker_id' => ''}
                  ] do
                    issue1 = Issue.generate!(:tracker_id => 2)
                    issue2 = Issue.generate!
                    Changeset.generate!(:comments => "Fixes ##{issue1.id}, ##{issue2.id}")
                    assert_equal 5, issue1.reload.status_id
                    assert_equal 3, issue2.reload.status_id
                  end
                end
                def test_update_keywords_with_multiple_rules_for_the_same_tracker_should_match_keyword
                  with_settings :commit_update_keywords => [
                    {'keywords' => 'Fixes, Closes', 'status_id' => '5', 'done_ratio' => '100', 'if_tracker_id' => '2'},
                    {'keywords' => 'Testing',       'status_id' => '3', 'done_ratio' => '90',  'if_tracker_id' => '2'}
                  ] do
                    issue1 = Issue.generate!(:tracker_id => 2)
                    issue2 = Issue.generate!(:tracker_id => 2)
                    Changeset.generate!(:comments => "Testing ##{issue1.id}, Fixes ##{issue2.id}")
                    issue1.reload
                    assert_equal 3, issue1.status_id
                    assert_equal 90, issue1.done_ratio
                    issue2.reload
                    assert_equal 5, issue2.status_id
                    assert_equal 100, issue2.done_ratio
                  end
                end
                def test_update_keywords_with_multiple_rules_and_no_match
                  with_settings :commit_update_keywords => [
                    {'keywords' => 'fixes', 'status_id' => '5', 'if_tracker_id' => '2'},
                    {'keywords' => 'fixes', 'status_id' => '3', 'if_tracker_id' => '3'}
                  ] do
                    issue1 = Issue.generate!(:tracker_id => 2)
                    issue2 = Issue.generate!
                    Changeset.generate!(:comments => "Fixes ##{issue1.id}, ##{issue2.id}")
                    assert_equal 5, issue1.reload.status_id
                    assert_equal 1, issue2.reload.status_id # no updates
                  end
                end
                def test_commit_referencing_a_subproject_issue
                  c = Changeset.new(:repository   => Project.find(1).repository,
                                    :committed_on => Time.now,
                                    :comments     => 'refs #5, a subproject issue',
                                    :revision     => '12345')
                  assert c.save
                  assert_equal [5], c.issue_ids.sort
                  assert c.issues.first.project != c.project
                end
                def test_commit_closing_a_subproject_issue
                  with_settings :commit_update_keywords => [{'keywords' => 'closes', 'status_id' => '5'}],
                                :default_language => 'en' do
                    issue = Issue.find(5)
                    assert !issue.closed?
                    assert_difference 'Journal.count' do
                      c = Changeset.new(:repository   => Project.find(1).repository,
                                        :committed_on => Time.now,
                                        :comments     => 'closes #5, a subproject issue',
                                        :revision     => '12345')
                      assert c.save
                    end
                    assert issue.reload.closed?
                    journal = Journal.order('id DESC').first
                    assert_equal issue, journal.issue
                    assert_include "Applied in changeset ecookbook:r12345.", journal.notes
                  end
                end
                def test_commit_referencing_a_parent_project_issue
                  # repository of child project
                  r = Repository::Subversion.create!(
                        :project => Project.find(3),
                        :url     => 'svn://localhost/test')
                  c = Changeset.new(:repository   => r,
                                    :committed_on => Time.now,
                                    :comments     => 'refs #2, an issue of a parent project',
                                    :revision     => '12345')
                  assert c.save
                  assert_equal [2], c.issue_ids.sort
                  assert c.issues.first.project != c.project
                end
                def test_commit_referencing_a_project_with_commit_cross_project_ref_disabled
                  r = Repository::Subversion.create!(
                        :project => Project.find(3),
                        :url     => 'svn://localhost/test')
                  with_settings :commit_cross_project_ref => '0' do
                    c = Changeset.new(:repository   => r,
                                      :committed_on => Time.now,
                                      :comments     => 'refs #4, an issue of a different project',
                                      :revision     => '12345')
                    assert c.save
                    assert_equal [], c.issue_ids
                  end
                end
                def test_commit_referencing_a_project_with_commit_cross_project_ref_enabled
                  r = Repository::Subversion.create!(
                        :project => Project.find(3),
                        :url     => 'svn://localhost/test')
                  with_settings :commit_cross_project_ref => '1' do
                    c = Changeset.new(:repository   => r,
                                      :committed_on => Time.now,
                                      :comments     => 'refs #4, an issue of a different project',
                                      :revision     => '12345')
                    assert c.save
                    assert_equal [4], c.issue_ids
                  end
                end
                def test_old_commits_should_not_update_issues_nor_log_time
                  Setting.commit_ref_keywords = '*'
                  Setting.commit_update_keywords = {'fixes , closes' => {'status_id' => '5', 'done_ratio' => '90'}}
                  Setting.commit_logtime_enabled = '1'
                  repository = Project.find(1).repository
                  repository.created_on = Time.now
                  repository.save!
                  c = Changeset.new(:repository   => repository,
                                    :committed_on => 1.month.ago,
                                    :comments     => 'New commit (#2). Fixes #1 @1h',
                                    :revision     => '12345')
                  assert_no_difference 'TimeEntry.count' do
                    assert c.save
                  end
                  assert_equal [1, 2], c.issue_ids.sort
                  issue = Issue.find(1)
                  assert_equal 1, issue.status_id
                  assert_equal 0, issue.done_ratio
                end
                def test_2_repositories_with_same_backend_should_not_link_issue_multiple_times
                  Setting.commit_ref_keywords = '*'
                  r1 = Repository::Subversion.create!(:project_id => 1, :identifier => 'svn1', :url => 'file:///svn1')
                  r2 = Repository::Subversion.create!(:project_id => 1, :identifier => 'svn2', :url => 'file:///svn1')
                  now = Time.now
                  assert_difference 'Issue.find(1).changesets.count' do
                    c1 = Changeset.create!(:repository => r1, :committed_on => now, :comments => 'Fixes #1', :revision => '12345')
                    c1 = Changeset.create!(:repository => r2, :committed_on => now, :comments => 'Fixes #1', :revision => '12345')
                  end
                end
                def test_text_tag_revision
                  c = Changeset.new(:revision => '520')
                  assert_equal 'r520', c.text_tag
                end
                def test_text_tag_revision_with_same_project
                  c = Changeset.new(:revision => '520', :repository => Project.find(1).repository)
                  assert_equal 'r520', c.text_tag(Project.find(1))
                end
                def test_text_tag_revision_with_different_project
                  c = Changeset.new(:revision => '520', :repository => Project.find(1).repository)
                  assert_equal 'ecookbook:r520', c.text_tag(Project.find(2))
                end
                def test_text_tag_revision_with_repository_identifier
                  r = Repository::Subversion.create!(
                        :project_id => 1,
                        :url     => 'svn://localhost/test',
                        :identifier => 'documents')
                  c = Changeset.new(:revision => '520', :repository => r)
                  assert_equal 'documents|r520', c.text_tag
                  assert_equal 'ecookbook:documents|r520', c.text_tag(Project.find(2))
                end
                def test_text_tag_hash
                  c = Changeset.new(
                        :scmid    => '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        :revision => '7234cb2750b63f47bff735edc50a1c0a433c2518')
                  assert_equal 'commit:7234cb2750b63f47bff735edc50a1c0a433c2518', c.text_tag
                end
                def test_text_tag_hash_with_same_project
                  c = Changeset.new(:revision => '7234cb27', :scmid => '7234cb27', :repository => Project.find(1).repository)
                  assert_equal 'commit:7234cb27', c.text_tag(Project.find(1))
                end
                def test_text_tag_hash_with_different_project
                  c = Changeset.new(:revision => '7234cb27', :scmid => '7234cb27', :repository => Project.find(1).repository)
                  assert_equal 'ecookbook:commit:7234cb27', c.text_tag(Project.find(2))
                end
                def test_text_tag_hash_all_number
                  c = Changeset.new(:scmid => '0123456789', :revision => '0123456789')
                  assert_equal 'commit:0123456789', c.text_tag
                end
                def test_text_tag_hash_with_repository_identifier
                  r = Repository::Subversion.new(
                        :project_id => 1,
                        :url     => 'svn://localhost/test',
                        :identifier => 'documents')
                  c = Changeset.new(:revision => '7234cb27', :scmid => '7234cb27', :repository => r)
                  assert_equal 'commit:documents|7234cb27', c.text_tag
                  assert_equal 'ecookbook:commit:documents|7234cb27', c.text_tag(Project.find(2))
                end
                def test_previous
                  changeset = Changeset.find_by_revision('3')
                  assert_equal Changeset.find_by_revision('2'), changeset.previous
                end
                def test_previous_nil
                  changeset = Changeset.find_by_revision('1')
                  assert_nil changeset.previous
                end
                def test_next
                  changeset = Changeset.find_by_revision('2')
                  assert_equal Changeset.find_by_revision('3'), changeset.next
                end
                def test_next_nil
                  changeset = Changeset.find_by_revision('10')
                  assert_nil changeset.next
                end
                def test_comments_should_be_converted_to_utf8
                  proj = Project.find(3)
                  # str = File.read("#{RAILS_ROOT}/test/fixtures/encoding/iso-8859-1.txt")
                  str = "Texte encod\xe9 en ISO-8859-1.".force_encoding("ASCII-8BIT")
                  r = Repository::Bazaar.create!(
                          :project      => proj,
                          :url          => '/tmp/test/bazaar',
                          :log_encoding => 'ISO-8859-1' )
                  assert r
                  c = Changeset.new(:repository   => r,
                                    :committed_on => Time.now,
                                    :revision     => '123',
                                    :scmid        => '12345',
                                    :comments     => str)
                  assert( c.save )
                  str_utf8 = "Texte encod\xc3\xa9 en ISO-8859-1.".force_encoding("UTF-8")
                  assert_equal str_utf8, c.comments
                end
                def test_invalid_utf8_sequences_in_comments_should_be_replaced_latin1
                  proj = Project.find(3)
                  # str = File.read("#{RAILS_ROOT}/test/fixtures/encoding/iso-8859-1.txt")
                  str1 = "Texte encod\xe9 en ISO-8859-1.".force_encoding("UTF-8")
                  str2 = "\xe9a\xe9b\xe9c\xe9d\xe9e test".force_encoding("ASCII-8BIT")
                  r = Repository::Bazaar.create!(
                          :project      => proj,
                          :url          => '/tmp/test/bazaar',
                          :log_encoding => 'UTF-8' )
                  assert r
                  c = Changeset.new(:repository   => r,
                                    :committed_on => Time.now,
                                    :revision     => '123',
                                    :scmid        => '12345',
                                    :comments     => str1,
                                    :committer    => str2)
                  assert( c.save )
                  assert_equal "Texte encod? en ISO-8859-1.", c.comments
                  assert_equal "?a?b?c?d?e test", c.committer
                end
                def test_invalid_utf8_sequences_in_comments_should_be_replaced_ja_jis
                  proj = Project.find(3)
                  str = "test\xb5\xfetest\xb5\xfe".force_encoding('ASCII-8BIT')
                  r = Repository::Bazaar.create!(
                          :project      => proj,
                          :url          => '/tmp/test/bazaar',
                          :log_encoding => 'ISO-2022-JP' )
                  assert r
                  c = Changeset.new(:repository   => r,
                                    :committed_on => Time.now,
                                    :revision     => '123',
                                    :scmid        => '12345',
                                    :comments     => str)
                  assert( c.save )
                  assert_equal "test??test??", c.comments
                end
                def test_comments_should_be_converted_all_latin1_to_utf8
                  s1 = "\xC2\x80"
                  s2 = "\xc3\x82\xc2\x80"
                  s4 = s2.dup
                  s3 = s1.dup
                  s1.force_encoding('ASCII-8BIT')
                  s2.force_encoding('ASCII-8BIT')
                  s3.force_encoding('ISO-8859-1')
                  s4.force_encoding('UTF-8')
                  assert_equal s3.encode('UTF-8'), s4
                  proj = Project.find(3)
                  r = Repository::Bazaar.create!(
                          :project      => proj,
                          :url          => '/tmp/test/bazaar',
                          :log_encoding => 'ISO-8859-1' )
                  assert r
                  c = Changeset.new(:repository   => r,
                                    :committed_on => Time.now,
                                    :revision     => '123',
                                    :scmid        => '12345',
                                    :comments     => s1)
                  assert( c.save )
                  assert_equal s4, c.comments
                end
                def test_invalid_utf8_sequences_in_paths_should_be_replaced
                  proj = Project.find(3)
                  str1 = "Texte encod\xe9 en ISO-8859-1".force_encoding("UTF-8")
                  str2 = "\xe9a\xe9b\xe9c\xe9d\xe9e test".force_encoding("ASCII-8BIT")
                  r = Repository::Bazaar.create!(
                          :project => proj,
                          :url => '/tmp/test/bazaar',
                          :log_encoding => 'UTF-8' )
                  assert r
                  cs = Changeset.new(
                             :repository   => r,
                             :committed_on => Time.now,
                             :revision     => '123',
                             :scmid        => '12345',
                             :comments     => "test")
                  assert(cs.save)
                  ch = Change.new(
                                :changeset     => cs,
                                :action        => "A",
                                :path          => str1,
                                :from_path     => str2,
                                :from_revision => "345")
                  assert(ch.save)
                  assert_equal "Texte encod? en ISO-8859-1", ch.path
                  assert_equal "?a?b?c?d?e test", ch.from_path
                end
                def test_comments_nil
                  proj = Project.find(3)
                  r = Repository::Bazaar.create!(
                          :project      => proj,
                          :url          => '/tmp/test/bazaar',
                          :log_encoding => 'ISO-8859-1' )
                  assert r
                  c = Changeset.new(:repository   => r,
                                    :committed_on => Time.now,
                                    :revision     => '123',
                                    :scmid        => '12345',
                                    :comments     => nil,
                                    :committer    => nil)
                  assert( c.save )
                  assert_equal "", c.comments
-                 assert_equal nil, c.committer
+                 assert_nil c.committer
                  assert_equal "UTF-8", c.comments.encoding.to_s
                end
                def test_comments_empty
                  proj = Project.find(3)
                  r = Repository::Bazaar.create!(
                          :project      => proj,
                          :url          => '/tmp/test/bazaar',
                          :log_encoding => 'ISO-8859-1' )
                  assert r
                  c = Changeset.new(:repository   => r,
                                    :committed_on => Time.now,
                                    :revision     => '123',
                                    :scmid        => '12345',
                                    :comments     => "",
                                    :committer    => "")
                  assert( c.save )
                  assert_equal "", c.comments
                  assert_equal "", c.committer
                  assert_equal "UTF-8", c.comments.encoding.to_s
                  assert_equal "UTF-8", c.committer.encoding.to_s
                end
                def test_comments_should_accept_more_than_64k
                  c = Changeset.new(:repository   => Repository.first,
                                    :committed_on => Time.now,
                                    :revision     => '123',
                                    :scmid        => '12345',
                                    :comments     => "a" * 500.kilobyte)
                  assert c.save
                  c.reload
                  assert_equal 500.kilobyte, c.comments.size
                end
                def test_identifier
                  c = Changeset.find_by_revision('1')
                  assert_equal c.revision, c.identifier
                end
              end

test/unit/custom_field_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 CustomFieldTest < ActiveSupport::TestCase
                fixtures :custom_fields, :roles, :projects,
                         :trackers, :issue_statuses,
                         :issues
                def test_create
                  field = UserCustomField.new(:name => 'Money money money', :field_format => 'float')
                  assert field.save
                end
                def test_before_validation
                  field = CustomField.new(:name => 'test_before_validation', :field_format => 'int')
                  field.searchable = true
                  assert field.save
                  assert_equal false, field.searchable
                  field.searchable = true
                  assert field.save
                  assert_equal false, field.searchable
                end
                def test_regexp_validation
                  field = IssueCustomField.new(:name => 'regexp', :field_format => 'text', :regexp => '[a-z0-9')
                  assert !field.save
                  assert_include I18n.t('activerecord.errors.messages.invalid'),
                                 field.errors[:regexp]
                  field.regexp = '[a-z0-9]'
                  assert field.save
                end
                def test_default_value_should_be_validated
                  field = CustomField.new(:name => 'Test', :field_format => 'int')
                  field.default_value = 'abc'
                  assert !field.valid?
                  field.default_value = '6'
                  assert field.valid?
                end
                def test_default_value_should_not_be_validated_when_blank
                  field = CustomField.new(:name => 'Test', :field_format => 'list', :possible_values => ['a', 'b'], :is_required => true, :default_value => '')
                  assert field.valid?
                end
                def test_field_format_should_be_validated
                  field = CustomField.new(:name => 'Test', :field_format => 'foo')
                  assert !field.valid?
                end
                def test_field_format_validation_should_accept_formats_added_at_runtime
                  Redmine::FieldFormat.add 'foobar', Class.new(Redmine::FieldFormat::Base)
                  field = CustomField.new(:name => 'Some Custom Field', :field_format => 'foobar')
                  assert field.valid?, 'field should be valid'
                ensure
                  Redmine::FieldFormat.delete 'foobar'
                end
                def test_should_not_change_field_format_of_existing_custom_field
                  field = CustomField.find(1)
                  field.field_format = 'int'
                  assert_equal 'list', field.field_format
                end
                def test_possible_values_should_accept_an_array
                  field = CustomField.new
                  field.possible_values = ["One value", ""]
                  assert_equal ["One value"], field.possible_values
                end
                def test_possible_values_should_stringify_values
                  field = CustomField.new
                  field.possible_values = [1, 2]
                  assert_equal ["1", "2"], field.possible_values
                end
                def test_possible_values_should_accept_a_string
                  field = CustomField.new
                  field.possible_values = "One value"
                  assert_equal ["One value"], field.possible_values
                end
                def test_possible_values_should_return_utf8_encoded_strings
                  field = CustomField.new
                  s = "Value".force_encoding('BINARY')
                  field.possible_values = s
                  assert_equal [s], field.possible_values
                  assert_equal 'UTF-8', field.possible_values.first.encoding.name
                end
                def test_possible_values_should_accept_a_multiline_string
                  field = CustomField.new
                  field.possible_values = "One value\nAnd another one  \r\n \n"
                  assert_equal ["One value", "And another one"], field.possible_values
                end
                def test_possible_values_stored_as_binary_should_be_utf8_encoded
                  field = CustomField.find(11)
                  assert_kind_of Array, field.possible_values
                  assert field.possible_values.size > 0
                  field.possible_values.each do |value|
                    assert_equal "UTF-8", value.encoding.name
                  end
                end
                def test_destroy
                  field = CustomField.find(1)
                  assert field.destroy
                end
                def test_new_subclass_instance_should_return_an_instance
                  f = CustomField.new_subclass_instance('IssueCustomField')
                  assert_kind_of IssueCustomField, f
                end
                def test_new_subclass_instance_should_set_attributes
                  f = CustomField.new_subclass_instance('IssueCustomField', :name => 'Test')
                  assert_kind_of IssueCustomField, f
                  assert_equal 'Test', f.name
                end
                def test_new_subclass_instance_with_invalid_class_name_should_return_nil
                  assert_nil CustomField.new_subclass_instance('WrongClassName')
                end
                def test_new_subclass_instance_with_non_subclass_name_should_return_nil
                  assert_nil CustomField.new_subclass_instance('Project')
                end
                def test_string_field_validation_with_blank_value
                  f = CustomField.new(:field_format => 'string')
                  assert f.valid_field_value?(nil)
                  assert f.valid_field_value?('')
                  f.is_required = true
                  assert !f.valid_field_value?(nil)
                  assert !f.valid_field_value?('')
                end
                def test_string_field_validation_with_min_and_max_lengths
                  f = CustomField.new(:field_format => 'string', :min_length => 2, :max_length => 5)
                  assert f.valid_field_value?(nil)
                  assert f.valid_field_value?('')
                  assert !f.valid_field_value?(' ')
                  assert f.valid_field_value?('a' * 2)
                  assert !f.valid_field_value?('a')
                  assert !f.valid_field_value?('a' * 6)
                end
                def test_string_field_validation_with_regexp
                  f = CustomField.new(:field_format => 'string', :regexp => '^[A-Z0-9]*$')
                  assert f.valid_field_value?(nil)
                  assert f.valid_field_value?('')
                  assert !f.valid_field_value?(' ')
                  assert f.valid_field_value?('ABC')
                  assert !f.valid_field_value?('abc')
                end
                def test_date_field_validation
                  f = CustomField.new(:field_format => 'date')
                  assert f.valid_field_value?(nil)
                  assert f.valid_field_value?('')
                  assert !f.valid_field_value?(' ')
                  assert f.valid_field_value?('1975-07-14')
                  assert !f.valid_field_value?('1975-07-33')
                  assert !f.valid_field_value?('abc')
                end
                def test_list_field_validation
                  f = CustomField.new(:field_format => 'list', :possible_values => ['value1', 'value2'])
                  assert f.valid_field_value?(nil)
                  assert f.valid_field_value?('')
                  assert !f.valid_field_value?(' ')
                  assert f.valid_field_value?('value2')
                  assert !f.valid_field_value?('abc')
                end
                def test_int_field_validation
                  f = CustomField.new(:field_format => 'int')
                  assert f.valid_field_value?(nil)
                  assert f.valid_field_value?('')
                  assert !f.valid_field_value?(' ')
                  assert f.valid_field_value?('123')
                  assert f.valid_field_value?('+123')
                  assert f.valid_field_value?('-123')
                  assert !f.valid_field_value?('6abc')
                  assert f.valid_field_value?(123)
                end
                def test_float_field_validation
                  f = CustomField.new(:field_format => 'float')
                  assert f.valid_field_value?(nil)
                  assert f.valid_field_value?('')
                  assert !f.valid_field_value?(' ')
                  assert f.valid_field_value?('11.2')
                  assert f.valid_field_value?('-6.250')
                  assert f.valid_field_value?('5')
                  assert !f.valid_field_value?('6abc')
                  assert f.valid_field_value?(11.2)
                end
                def test_multi_field_validation
                  f = CustomField.new(:field_format => 'list', :multiple => 'true', :possible_values => ['value1', 'value2'])
                  assert f.valid_field_value?(nil)
                  assert f.valid_field_value?('')
                  assert !f.valid_field_value?(' ')
                  assert f.valid_field_value?([])
                  assert f.valid_field_value?([nil])
                  assert f.valid_field_value?([''])
                  assert !f.valid_field_value?([' '])
                  assert f.valid_field_value?('value2')
                  assert !f.valid_field_value?('abc')
                  assert f.valid_field_value?(['value2'])
                  assert !f.valid_field_value?(['abc'])
                  assert f.valid_field_value?(['', 'value2'])
                  assert !f.valid_field_value?(['', 'abc'])
                  assert f.valid_field_value?(['value1', 'value2'])
                  assert !f.valid_field_value?(['value1', 'abc'])
                end
                def test_changing_multiple_to_false_should_delete_multiple_values
                  field = ProjectCustomField.create!(:name => 'field', :field_format => 'list', :multiple => 'true', :possible_values => ['field1', 'field2'])
                  other = ProjectCustomField.create!(:name => 'other', :field_format => 'list', :multiple => 'true', :possible_values => ['other1', 'other2'])
                  item_with_multiple_values = Project.generate!(:custom_field_values => {field.id => ['field1', 'field2'], other.id => ['other1', 'other2']})
                  item_with_single_values = Project.generate!(:custom_field_values => {field.id => ['field1'], other.id => ['other2']})
                  assert_difference 'CustomValue.count', -1 do
                    field.multiple = false
                    field.save!
                  end
                  item_with_multiple_values = Project.find(item_with_multiple_values.id)
                  assert_kind_of String, item_with_multiple_values.custom_field_value(field)
                  assert_kind_of Array, item_with_multiple_values.custom_field_value(other)
                  assert_equal 2, item_with_multiple_values.custom_field_value(other).size
                end
                def test_value_class_should_return_the_class_used_for_fields_values
                  assert_equal User, CustomField.new(:field_format => 'user').value_class
                  assert_equal Version, CustomField.new(:field_format => 'version').value_class
                end
                def test_value_class_should_return_nil_for_other_fields
                  assert_nil CustomField.new(:field_format => 'text').value_class
                  assert_nil CustomField.new.value_class
                end
                def test_value_from_keyword_for_list_custom_field
                  field = CustomField.find(1)
                  assert_equal 'PostgreSQL', field.value_from_keyword('postgresql', Issue.find(1))
                end
                def test_visibile_scope_with_admin_should_return_all_custom_fields
                  admin = User.generate! {|user| user.admin = true}
                  CustomField.delete_all
                  fields = [
                    CustomField.generate!(:visible => true),
                    CustomField.generate!(:visible => false),
                    CustomField.generate!(:visible => false, :role_ids => [1, 3]),
                    CustomField.generate!(:visible => false, :role_ids => [1, 2]),
                  ]
                  assert_equal 4, CustomField.visible(admin).count
                end
                def test_visibile_scope_with_non_admin_user_should_return_visible_custom_fields
                  CustomField.delete_all
                  fields = [
                    CustomField.generate!(:visible => true),
                    CustomField.generate!(:visible => false),
                    CustomField.generate!(:visible => false, :role_ids => [1, 3]),
                    CustomField.generate!(:visible => false, :role_ids => [1, 2]),
                  ]
                  user = User.generate!
                  User.add_to_project(user, Project.first, Role.find(3))
                  assert_equal [fields[0], fields[2]], CustomField.visible(user).order("id").to_a
                end
                def test_visibile_scope_with_anonymous_user_should_return_visible_custom_fields
                  CustomField.delete_all
                  fields = [
                    CustomField.generate!(:visible => true),
                    CustomField.generate!(:visible => false),
                    CustomField.generate!(:visible => false, :role_ids => [1, 3]),
                    CustomField.generate!(:visible => false, :role_ids => [1, 2]),
                  ]
                  assert_equal [fields[0]], CustomField.visible(User.anonymous).order("id").to_a
                end
                def test_float_cast_blank_value_should_return_nil
                  field = CustomField.new(:field_format => 'float')
-                 assert_equal nil, field.cast_value(nil)
-                 assert_equal nil, field.cast_value('')
+                 assert_nil field.cast_value(nil)
+                 assert_nil field.cast_value('')
                end
                def test_float_cast_valid_value_should_return_float
                  field = CustomField.new(:field_format => 'float')
                  assert_equal 12.0, field.cast_value('12')
                  assert_equal 12.5, field.cast_value('12.5')
                  assert_equal 12.5, field.cast_value('+12.5')
                  assert_equal -12.5, field.cast_value('-12.5')
                end
              end

test/unit/custom_field_user_format_test.rb +3 -3

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 CustomFieldUserFormatTest < ActiveSupport::TestCase
                fixtures :custom_fields, :projects, :members, :users, :member_roles, :trackers, :issues
                def setup
                  @field = IssueCustomField.create!(:name => 'Tester', :field_format => 'user')
                end
                def test_possible_values_options_with_no_arguments
                  assert_equal [], @field.possible_values_options
                  assert_equal [], @field.possible_values_options(nil)
                end
                def test_possible_values_options_with_project_resource
                  project = Project.find(1)
                  possible_values_options = @field.possible_values_options(project.issues.first)
                  assert possible_values_options.any?
                  assert_equal project.users.sort.map {|u| [u.name, u.id.to_s]}, possible_values_options
                end
                def test_possible_values_options_with_array
                  projects = Project.find([1, 2])
                  possible_values_options = @field.possible_values_options(projects)
                  assert possible_values_options.any?
                  assert_equal (projects.first.users & projects.last.users).sort.map {|u| [u.name, u.id.to_s]}, possible_values_options
                end
                def test_possible_custom_value_options_should_not_include_locked_users
                  custom_value = CustomValue.new(:customized => Issue.find(1), :custom_field => @field)
                  assert_include '2', @field.possible_custom_value_options(custom_value).map(&:last)
                  assert User.find(2).lock!
                  assert_not_include '2', @field.possible_custom_value_options(custom_value).map(&:last)
                end
                def test_possible_custom_value_options_should_include_user_that_was_assigned_to_the_custom_value
                  user = User.generate!
                  custom_value = CustomValue.new(:customized => Issue.find(1), :custom_field => @field)
                  assert_not_include user.id.to_s, @field.possible_custom_value_options(custom_value).map(&:last)
                  custom_value.value = user.id
                  custom_value.save!
                  assert_include user.id.to_s, @field.possible_custom_value_options(custom_value).map(&:last)
                end
                def test_cast_blank_value
-                 assert_equal nil, @field.cast_value(nil)
-                 assert_equal nil, @field.cast_value("")
+                 assert_nil @field.cast_value(nil)
+                 assert_nil @field.cast_value("")
                end
                def test_cast_valid_value
                  user = @field.cast_value("2")
                  assert_kind_of User, user
                  assert_equal User.find(2), user
                end
                def test_cast_invalid_value
-                 assert_equal nil, @field.cast_value("187")
+                 assert_nil @field.cast_value("187")
                end
              end

test/unit/custom_field_version_format_test.rb +3 -3

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 CustomFieldVersionFormatTest < ActiveSupport::TestCase
                fixtures :custom_fields, :projects, :members, :users, :member_roles, :trackers, :issues, :versions
                def setup
                  @field = IssueCustomField.create!(:name => 'Tester', :field_format => 'version')
                end
                def test_possible_values_options_with_no_arguments
                  Version.delete_all
                  assert_equal [], @field.possible_values_options
                  assert_equal [], @field.possible_values_options(nil)
                end
                def test_possible_values_options_with_project_resource
                  project = Project.find(1)
                  possible_values_options = @field.possible_values_options(project.issues.first)
                  assert possible_values_options.any?
                  assert_equal project.shared_versions.sort.map {|u| [u.name, u.id.to_s]}, possible_values_options
                end
                def test_possible_values_options_with_array
                  projects = Project.find([1, 2])
                  possible_values_options = @field.possible_values_options(projects)
                  assert possible_values_options.any?
                  assert_equal (projects.first.shared_versions & projects.last.shared_versions).sort.map {|u| [u.name, u.id.to_s]}, possible_values_options
                end
                def test_cast_blank_value
-                 assert_equal nil, @field.cast_value(nil)
-                 assert_equal nil, @field.cast_value("")
+                 assert_nil @field.cast_value(nil)
+                 assert_nil @field.cast_value("")
                end
                def test_cast_valid_value
                  version = @field.cast_value("2")
                  assert_kind_of Version, version
                  assert_equal Version.find(2), version
                end
                def test_cast_invalid_value
-                 assert_equal nil, @field.cast_value("187")
+                 assert_nil @field.cast_value("187")
                end
              end

test/unit/group_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 GroupTest < ActiveSupport::TestCase
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :enumerations, :users,
                         :projects_trackers,
                         :roles,
                         :member_roles,
                         :members,
                         :groups_users
                include Redmine::I18n
                def test_create
                  g = Group.new(:name => 'New group')
                  assert g.save
                  g.reload
                  assert_equal 'New group', g.name
                end
                def test_name_should_accept_255_characters
                  name = 'a' * 255
                  g = Group.new(:name => name)
                  assert g.save
                  g.reload
                  assert_equal name, g.name
                end
                def test_blank_name_error_message
                  set_language_if_valid 'en'
                  g = Group.new
                  assert !g.save
                  assert_include "Name cannot be blank", g.errors.full_messages
                end
                def test_blank_name_error_message_fr
                  set_language_if_valid 'fr'
                  str = "Nom doit \xc3\xaatre renseign\xc3\xa9(e)".force_encoding('UTF-8')
                  g = Group.new
                  assert !g.save
                  assert_include str, g.errors.full_messages
                end
                def test_group_roles_should_be_given_to_added_user
                  group = Group.find(11)
                  user = User.find(9)
                  project = Project.first
                  Member.create!(:principal => group, :project => project, :role_ids => [1, 2])
                  group.users << user
                  assert user.member_of?(project)
                end
                def test_new_roles_should_be_given_to_existing_user
                  group = Group.find(11)
                  user = User.find(9)
                  project = Project.first
                  group.users << user
                  m = Member.create!(:principal => group, :project => project, :role_ids => [1, 2])
                  assert user.member_of?(project)
                end
                def test_user_roles_should_updated_when_updating_user_ids
                  group = Group.find(11)
                  user = User.find(9)
                  project = Project.first
                  Member.create!(:principal => group, :project => project, :role_ids => [1, 2])
                  group.user_ids = [user.id]
                  group.save!
                  assert User.find(9).member_of?(project)
                  group.user_ids = [1]
                  group.save!
                  assert !User.find(9).member_of?(project)
                end
                def test_user_roles_should_updated_when_updating_group_roles
                  group = Group.find(11)
                  user = User.find(9)
                  project = Project.first
                  group.users << user
                  m = Member.create!(:principal => group, :project => project, :role_ids => [1])
                  assert_equal [1], user.reload.roles_for_project(project).collect(&:id).sort
                  m.role_ids = [1, 2]
                  assert_equal [1, 2], user.reload.roles_for_project(project).collect(&:id).sort
                  m.role_ids = [2]
                  assert_equal [2], user.reload.roles_for_project(project).collect(&:id).sort
                  m.role_ids = [1]
                  assert_equal [1], user.reload.roles_for_project(project).collect(&:id).sort
                end
                def test_user_memberships_should_be_removed_when_removing_group_membership
                  assert User.find(8).member_of?(Project.find(5))
                  Member.find_by_project_id_and_user_id(5, 10).destroy
                  assert !User.find(8).member_of?(Project.find(5))
                end
                def test_user_roles_should_be_removed_when_removing_user_from_group
                  assert User.find(8).member_of?(Project.find(5))
                  User.find(8).groups = []
                  assert !User.find(8).member_of?(Project.find(5))
                end
                def test_destroy_should_unassign_issues
                  group = Group.find(10)
                  Issue.where(:id => 1).update_all(["assigned_to_id = ?", group.id])
                  assert group.destroy
                  assert group.destroyed?
-                 assert_equal nil, Issue.find(1).assigned_to_id
+                 assert_nil Issue.find(1).assigned_to_id
                end
                def test_builtin_groups_should_be_created_if_missing
                  Group.delete_all
                  assert_difference 'Group.count', 2 do
                    group = Group.anonymous
                    assert_equal GroupAnonymous, group.class
                    group = Group.non_member
                    assert_equal GroupNonMember, group.class
                  end
                end
                def test_builtin_in_group_should_be_uniq
                  group = GroupAnonymous.new
                  group.name = 'Foo'
                  assert !group.save
                end
                def test_builtin_in_group_should_not_accept_users
                  group = Group.anonymous
                  assert_raise RuntimeError do
                    group.users << User.find(1)
                  end
                  assert_equal 0, group.reload.users.count
                end
                def test_sorted_scope_should_sort_groups_alphabetically
                  Group.delete_all
                  b = Group.generate!(:name => 'B')
                  a = Group.generate!(:name => 'A')
                  assert_equal %w(A B), Group.sorted.to_a.map(&:name)
                end
              end

test/unit/helpers/application_helper_test.rb +1 -1

              # encoding: utf-8
              #
              # Redmine - project management software
              # Copyright (C) 2006-2016  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 ApplicationHelperTest < Redmine::HelperTest
                include Redmine::I18n
                include ERB::Util
                include Rails.application.routes.url_helpers
                fixtures :projects, :enabled_modules,
                         :users, :email_addresses,
                         :members, :member_roles, :roles,
                         :repositories, :changesets,
                         :projects_trackers,
                         :trackers, :issue_statuses, :issues, :versions, :documents,
                         :wikis, :wiki_pages, :wiki_contents,
                         :boards, :messages, :news,
                         :attachments, :enumerations
                def setup
                  super
                  set_tmp_attachments_directory
                  @russian_test = "\xd1\x82\xd0\xb5\xd1\x81\xd1\x82".force_encoding('UTF-8')
                end
                test "#link_to_if_authorized for authorized user should allow using the :controller and :action for the target link" do
                  User.current = User.find_by_login('admin')
                  @project = Issue.first.project # Used by helper
                  response = link_to_if_authorized('By controller/actionr',
                                                  {:controller => 'issues', :action => 'edit', :id => Issue.first.id})
                  assert_match /href/, response
                end
                test "#link_to_if_authorized for unauthorized user should display nothing if user isn't authorized" do
                  User.current = User.find_by_login('dlopper')
                  @project = Project.find('private-child')
                  issue = @project.issues.first
                  assert !issue.visible?
                  response = link_to_if_authorized('Never displayed',
                                                  {:controller => 'issues', :action => 'show', :id => issue})
                  assert_nil response
                end
                def test_auto_links
                  to_test = {
                    'http://foo.bar' => '<a class="external" href="http://foo.bar">http://foo.bar</a>',
                    'http://foo.bar/~user' => '<a class="external" href="http://foo.bar/~user">http://foo.bar/~user</a>',
                    'http://foo.bar.' => '<a class="external" href="http://foo.bar">http://foo.bar</a>.',
                    'https://foo.bar.' => '<a class="external" href="https://foo.bar">https://foo.bar</a>.',
                    'This is a link: http://foo.bar.' => 'This is a link: <a class="external" href="http://foo.bar">http://foo.bar</a>.',
                    'A link (eg. http://foo.bar).' => 'A link (eg. <a class="external" href="http://foo.bar">http://foo.bar</a>).',
                    'http://foo.bar/foo.bar#foo.bar.' => '<a class="external" href="http://foo.bar/foo.bar#foo.bar">http://foo.bar/foo.bar#foo.bar</a>.',
                    'http://www.foo.bar/Test_(foobar)' => '<a class="external" href="http://www.foo.bar/Test_(foobar)">http://www.foo.bar/Test_(foobar)</a>',
                    '(see inline link : http://www.foo.bar/Test_(foobar))' => '(see inline link : <a class="external" href="http://www.foo.bar/Test_(foobar)">http://www.foo.bar/Test_(foobar)</a>)',
                    '(see inline link : http://www.foo.bar/Test)' => '(see inline link : <a class="external" href="http://www.foo.bar/Test">http://www.foo.bar/Test</a>)',
                    '(see inline link : http://www.foo.bar/Test).' => '(see inline link : <a class="external" href="http://www.foo.bar/Test">http://www.foo.bar/Test</a>).',
                    '(see "inline link":http://www.foo.bar/Test_(foobar))' => '(see <a href="http://www.foo.bar/Test_(foobar)" class="external">inline link</a>)',
                    '(see "inline link":http://www.foo.bar/Test)' => '(see <a href="http://www.foo.bar/Test" class="external">inline link</a>)',
                    '(see "inline link":http://www.foo.bar/Test).' => '(see <a href="http://www.foo.bar/Test" class="external">inline link</a>).',
                    'www.foo.bar' => '<a class="external" href="http://www.foo.bar">www.foo.bar</a>',
                    'http://foo.bar/page?p=1&t=z&s=' => '<a class="external" href="http://foo.bar/page?p=1&#38;t=z&#38;s=">http://foo.bar/page?p=1&#38;t=z&#38;s=</a>',
                    'http://foo.bar/page#125' => '<a class="external" href="http://foo.bar/page#125">http://foo.bar/page#125</a>',
                    'http://foo@www.bar.com' => '<a class="external" href="http://foo@www.bar.com">http://foo@www.bar.com</a>',
                    'http://foo:bar@www.bar.com' => '<a class="external" href="http://foo:bar@www.bar.com">http://foo:bar@www.bar.com</a>',
                    'ftp://foo.bar' => '<a class="external" href="ftp://foo.bar">ftp://foo.bar</a>',
                    'ftps://foo.bar' => '<a class="external" href="ftps://foo.bar">ftps://foo.bar</a>',
                    'sftp://foo.bar' => '<a class="external" href="sftp://foo.bar">sftp://foo.bar</a>',
                    # two exclamation marks
                    'http://example.net/path!602815048C7B5C20!302.html' => '<a class="external" href="http://example.net/path!602815048C7B5C20!302.html">http://example.net/path!602815048C7B5C20!302.html</a>',
                    # escaping
                    'http://foo"bar' => '<a class="external" href="http://foo&quot;bar">http://foo&quot;bar</a>',
                    # wrap in angle brackets
                    '<http://foo.bar>' => '&lt;<a class="external" href="http://foo.bar">http://foo.bar</a>&gt;',
                    # invalid urls
                    'http://' => 'http://',
                    'www.' => 'www.',
                    'test-www.bar.com' => 'test-www.bar.com',
                  }
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                end
                def test_auto_links_with_non_ascii_characters
                  to_test = {
                    "http://foo.bar/#{@russian_test}" =>
                      %|<a class="external" href="http://foo.bar/#{@russian_test}">http://foo.bar/#{@russian_test}</a>|
                  }
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                end
                def test_auto_mailto
                  to_test = {
                    'test@foo.bar' => '<a class="email" href="mailto:test@foo.bar">test@foo.bar</a>',
                    'test@www.foo.bar' => '<a class="email" href="mailto:test@www.foo.bar">test@www.foo.bar</a>',
                  }
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                end
                def test_inline_images
                  to_test = {
                    '!http://foo.bar/image.jpg!' => '<img src="http://foo.bar/image.jpg" alt="" />',
                    'floating !>http://foo.bar/image.jpg!' => 'floating <span style="float:right"><img src="http://foo.bar/image.jpg" alt="" /></span>',
                    'with class !(some-class)http://foo.bar/image.jpg!' => 'with class <img src="http://foo.bar/image.jpg" class="some-class" alt="" />',
                    'with style !{width:100px;height:100px}http://foo.bar/image.jpg!' => 'with style <img src="http://foo.bar/image.jpg" style="width:100px;height:100px;" alt="" />',
                    'with title !http://foo.bar/image.jpg(This is a title)!' => 'with title <img src="http://foo.bar/image.jpg" title="This is a title" alt="This is a title" />',
                    'with title !http://foo.bar/image.jpg(This is a double-quoted "title")!' => 'with title <img src="http://foo.bar/image.jpg" title="This is a double-quoted &quot;title&quot;" alt="This is a double-quoted &quot;title&quot;" />',
                  }
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                end
                def test_inline_images_inside_tags
                  raw = <<-RAW
              h1. !foo.png! Heading
              Centered image:
              p=. !bar.gif!
              RAW
                  assert textilizable(raw).include?('<img src="foo.png" alt="" />')
                  assert textilizable(raw).include?('<img src="bar.gif" alt="" />')
                end
                def test_attached_images
                  to_test = {
                    'Inline image: !logo.gif!' => 'Inline image: <img src="/attachments/download/3/logo.gif" title="This is a logo" alt="This is a logo" />',
                    'Inline image: !logo.GIF!' => 'Inline image: <img src="/attachments/download/3/logo.gif" title="This is a logo" alt="This is a logo" />',
                    'No match: !ogo.gif!' => 'No match: <img src="ogo.gif" alt="" />',
                    'No match: !ogo.GIF!' => 'No match: <img src="ogo.GIF" alt="" />',
                    # link image
                    '!logo.gif!:http://foo.bar/' => '<a href="http://foo.bar/"><img src="/attachments/download/3/logo.gif" title="This is a logo" alt="This is a logo" /></a>',
                  }
                  attachments = Attachment.all
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text, :attachments => attachments) }
                end
                def test_attached_images_with_textile_and_non_ascii_filename
                  attachment = Attachment.generate!(:filename => 'café.jpg')
                  with_settings :text_formatting => 'textile' do
                    assert_include %(<img src="/attachments/download/#{attachment.id}/caf%C3%A9.jpg" alt="" />),
                      textilizable("!café.jpg!)", :attachments => [attachment])
                  end
                end
                def test_attached_images_with_markdown_and_non_ascii_filename
                  skip unless Object.const_defined?(:Redcarpet)
                  attachment = Attachment.generate!(:filename => 'café.jpg')
                  with_settings :text_formatting => 'markdown' do
                    assert_include %(<img src="/attachments/download/#{attachment.id}/caf%C3%A9.jpg" alt="" />),
                      textilizable("![](café.jpg)", :attachments => [attachment])
                  end
                end
                def test_attached_images_filename_extension
                  set_tmp_attachments_directory
                  a1 = Attachment.new(
                          :container => Issue.find(1),
                          :file => mock_file_with_options({:original_filename => "testtest.JPG"}),
                          :author => User.find(1))
                  assert a1.save
                  assert_equal "testtest.JPG", a1.filename
                  assert_equal "image/jpeg", a1.content_type
                  assert a1.image?
                  a2 = Attachment.new(
                          :container => Issue.find(1),
                          :file => mock_file_with_options({:original_filename => "testtest.jpeg"}),
                          :author => User.find(1))
                  assert a2.save
                  assert_equal "testtest.jpeg", a2.filename
                  assert_equal "image/jpeg", a2.content_type
                  assert a2.image?
                  a3 = Attachment.new(
                          :container => Issue.find(1),
                          :file => mock_file_with_options({:original_filename => "testtest.JPE"}),
                          :author => User.find(1))
                  assert a3.save
                  assert_equal "testtest.JPE", a3.filename
                  assert_equal "image/jpeg", a3.content_type
                  assert a3.image?
                  a4 = Attachment.new(
                          :container => Issue.find(1),
                          :file => mock_file_with_options({:original_filename => "Testtest.BMP"}),
                          :author => User.find(1))
                  assert a4.save
                  assert_equal "Testtest.BMP", a4.filename
                  assert_equal "image/x-ms-bmp", a4.content_type
                  assert a4.image?
                  to_test = {
                    'Inline image: !testtest.jpg!' =>
                      'Inline image: <img src="/attachments/download/' + a1.id.to_s + '/testtest.JPG" alt="" />',
                    'Inline image: !testtest.jpeg!' =>
                      'Inline image: <img src="/attachments/download/' + a2.id.to_s + '/testtest.jpeg" alt="" />',
                    'Inline image: !testtest.jpe!' =>
                      'Inline image: <img src="/attachments/download/' + a3.id.to_s + '/testtest.JPE" alt="" />',
                    'Inline image: !testtest.bmp!' =>
                      'Inline image: <img src="/attachments/download/' + a4.id.to_s + '/Testtest.BMP" alt="" />',
                  }
                  attachments = [a1, a2, a3, a4]
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text, :attachments => attachments) }
                end
                def test_attached_images_should_read_later
                  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
                  to_test = {
                    'Inline image: !testfile.png!' =>
                      'Inline image: <img src="/attachments/download/' + a2.id.to_s + '/testfile.PNG" alt="" />',
                    'Inline image: !Testfile.PNG!' =>
                      'Inline image: <img src="/attachments/download/' + a2.id.to_s + '/testfile.PNG" alt="" />',
                  }
                  attachments = [a1, a2]
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text, :attachments => attachments) }
                  set_tmp_attachments_directory
                end
                def test_textile_external_links
                  to_test = {
                    'This is a "link":http://foo.bar' => 'This is a <a href="http://foo.bar" class="external">link</a>',
                    'This is an intern "link":/foo/bar' => 'This is an intern <a href="/foo/bar">link</a>',
                    '"link (Link title)":http://foo.bar' => '<a href="http://foo.bar" title="Link title" class="external">link</a>',
                    '"link (Link title with "double-quotes")":http://foo.bar' => '<a href="http://foo.bar" title="Link title with &quot;double-quotes&quot;" class="external">link</a>',
                    "This is not a \"Link\":\n\nAnother paragraph" => "This is not a \"Link\":</p>\n\n\n\t<p>Another paragraph",
                    # no multiline link text
                    "This is a double quote \"on the first line\nand another on a second line\":test" => "This is a double quote \"on the first line<br />and another on a second line\":test",
                    # mailto link
                    "\"system administrator\":mailto:sysadmin@example.com?subject=redmine%20permissions" => "<a href=\"mailto:sysadmin@example.com?subject=redmine%20permissions\">system administrator</a>",
                    # two exclamation marks
                    '"a link":http://example.net/path!602815048C7B5C20!302.html' => '<a href="http://example.net/path!602815048C7B5C20!302.html" class="external">a link</a>',
                    # escaping
                    '"test":http://foo"bar' => '<a href="http://foo&quot;bar" class="external">test</a>',
                  }
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                end
                def test_textile_external_links_with_non_ascii_characters
                  to_test = {
                    %|This is a "link":http://foo.bar/#{@russian_test}| =>
                      %|This is a <a href="http://foo.bar/#{@russian_test}" class="external">link</a>|
                  }
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                end
                def test_redmine_links
                  issue_link = link_to('#3', {:controller => 'issues', :action => 'show', :id => 3},
                                             :class => Issue.find(3).css_classes, :title => 'Bug: Error 281 when updating a recipe (New)')
                  note_link = link_to('#3-14', {:controller => 'issues', :action => 'show', :id => 3, :anchor => 'note-14'},
                                             :class => Issue.find(3).css_classes, :title => 'Bug: Error 281 when updating a recipe (New)')
                  note_link2 = link_to('#3#note-14', {:controller => 'issues', :action => 'show', :id => 3, :anchor => 'note-14'},
                                             :class => Issue.find(3).css_classes, :title => 'Bug: Error 281 when updating a recipe (New)')
                  revision_link = link_to('r1', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :rev => 1},
                                                 :class => 'changeset', :title => 'My very first commit do not escaping #<>&')
                  revision_link2 = link_to('r2', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :rev => 2},
                                                  :class => 'changeset', :title => 'This commit fixes #1, #2 and references #1 & #3')
                  changeset_link2 = link_to('691322a8eb01e11fd7',
                                            {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :rev => 1},
                                             :class => 'changeset', :title => 'My very first commit do not escaping #<>&')
                  document_link = link_to('Test document', {:controller => 'documents', :action => 'show', :id => 1},
                                                           :class => 'document')
                  version_link = link_to('1.0', {:controller => 'versions', :action => 'show', :id => 2},
                                                :class => 'version')
                  board_url = {:controller => 'boards', :action => 'show', :id => 2, :project_id => 'ecookbook'}
                  message_url = {:controller => 'messages', :action => 'show', :board_id => 1, :id => 4}
                  news_url = {:controller => 'news', :action => 'show', :id => 1}
                  project_url = {:controller => 'projects', :action => 'show', :id => 'subproject1'}
                  source_url = '/projects/ecookbook/repository/entry/some/file'
                  source_url_with_rev = '/projects/ecookbook/repository/revisions/52/entry/some/file'
                  source_url_with_ext = '/projects/ecookbook/repository/entry/some/file.ext'
                  source_url_with_rev_and_ext = '/projects/ecookbook/repository/revisions/52/entry/some/file.ext'
                  source_url_with_branch = '/projects/ecookbook/repository/revisions/branch/entry/some/file'
                  export_url = '/projects/ecookbook/repository/raw/some/file'
                  export_url_with_rev = '/projects/ecookbook/repository/revisions/52/raw/some/file'
                  export_url_with_ext = '/projects/ecookbook/repository/raw/some/file.ext'
                  export_url_with_rev_and_ext = '/projects/ecookbook/repository/revisions/52/raw/some/file.ext'
                  export_url_with_branch = '/projects/ecookbook/repository/revisions/branch/raw/some/file'
                  to_test = {
                    # tickets
                    '#3, [#3], (#3) and #3.'      => "#{issue_link}, [#{issue_link}], (#{issue_link}) and #{issue_link}.",
                    # ticket notes
                    '#3-14'                       => note_link,
                    '#3#note-14'                  => note_link2,
                    # should not ignore leading zero
                    '#03'                         => '#03',
                    # changesets
                    'r1'                          => revision_link,
                    'r1.'                         => "#{revision_link}.",
                    'r1, r2'                      => "#{revision_link}, #{revision_link2}",
                    'r1,r2'                       => "#{revision_link},#{revision_link2}",
                    'commit:691322a8eb01e11fd7'   => changeset_link2,
                    # documents
                    'document#1'                  => document_link,
                    'document:"Test document"'    => document_link,
                    # versions
                    'version#2'                   => version_link,
                    'version:1.0'                 => version_link,
                    'version:"1.0"'               => version_link,
                    # source
                    'source:some/file'            => link_to('source:some/file', source_url, :class => 'source'),
                    'source:/some/file'           => link_to('source:/some/file', source_url, :class => 'source'),
                    'source:/some/file.'          => link_to('source:/some/file', source_url, :class => 'source') + ".",
                    'source:/some/file.ext.'      => link_to('source:/some/file.ext', source_url_with_ext, :class => 'source') + ".",
                    'source:/some/file. '         => link_to('source:/some/file', source_url, :class => 'source') + ".",
                    'source:/some/file.ext. '     => link_to('source:/some/file.ext', source_url_with_ext, :class => 'source') + ".",
                    'source:/some/file, '         => link_to('source:/some/file', source_url, :class => 'source') + ",",
                    'source:/some/file@52'        => link_to('source:/some/file@52', source_url_with_rev, :class => 'source'),
                    'source:/some/file@branch'    => link_to('source:/some/file@branch', source_url_with_branch, :class => 'source'),
                    'source:/some/file.ext@52'    => link_to('source:/some/file.ext@52', source_url_with_rev_and_ext, :class => 'source'),
                    'source:/some/file#L110'      => link_to('source:/some/file#L110', source_url + "#L110", :class => 'source'),
                    'source:/some/file.ext#L110'  => link_to('source:/some/file.ext#L110', source_url_with_ext + "#L110", :class => 'source'),
                    'source:/some/file@52#L110'   => link_to('source:/some/file@52#L110', source_url_with_rev + "#L110", :class => 'source'),
                    # export
                    'export:/some/file'           => link_to('export:/some/file', export_url, :class => 'source download'),
                    'export:/some/file.ext'       => link_to('export:/some/file.ext', export_url_with_ext, :class => 'source download'),
                    'export:/some/file@52'        => link_to('export:/some/file@52', export_url_with_rev, :class => 'source download'),
                    'export:/some/file.ext@52'    => link_to('export:/some/file.ext@52', export_url_with_rev_and_ext, :class => 'source download'),
                    'export:/some/file@branch'    => link_to('export:/some/file@branch', export_url_with_branch, :class => 'source download'),
                    # forum
                    'forum#2'                     => link_to('Discussion', board_url, :class => 'board'),
                    'forum:Discussion'            => link_to('Discussion', board_url, :class => 'board'),
                    # message
                    'message#4'                   => link_to('Post 2', message_url, :class => 'message'),
                    'message#5'                   => link_to('RE: post 2', message_url.merge(:anchor => 'message-5', :r => 5), :class => 'message'),
                    # news
                    'news#1'                      => link_to('eCookbook first release !', news_url, :class => 'news'),
                    'news:"eCookbook first release !"'        => link_to('eCookbook first release !', news_url, :class => 'news'),
                    # project
                    'project#3'                   => link_to('eCookbook Subproject 1', project_url, :class => 'project'),
                    'project:subproject1'         => link_to('eCookbook Subproject 1', project_url, :class => 'project'),
                    'project:"eCookbook subProject 1"'        => link_to('eCookbook Subproject 1', project_url, :class => 'project'),
                    # not found
                    '#0123456789'                 => '#0123456789',
                    # invalid expressions
                    'source:'                     => 'source:',
                    # url hash
                    "http://foo.bar/FAQ#3"       => '<a class="external" href="http://foo.bar/FAQ#3">http://foo.bar/FAQ#3</a>',
                  }
                  @project = Project.find(1)
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text), "#{text} failed" }
                end
                def test_should_not_parse_redmine_links_inside_link
                  raw = "r1 should not be parsed in http://example.com/url-r1/"
                  assert_match %r{<p><a class="changeset".*>r1</a> should not be parsed in <a class="external" href="http://example.com/url-r1/">http://example.com/url-r1/</a></p>},
                    textilizable(raw, :project => Project.find(1))
                end
                def test_redmine_links_with_a_different_project_before_current_project
                  vp1 = Version.generate!(:project_id => 1, :name => '1.4.4')
                  vp3 = Version.generate!(:project_id => 3, :name => '1.4.4')
                  @project = Project.find(3)
                  result1 = link_to("1.4.4", "/versions/#{vp1.id}", :class => "version")
                  result2 = link_to("1.4.4", "/versions/#{vp3.id}", :class => "version")
                  assert_equal "<p>#{result1} #{result2}</p>",
                               textilizable("ecookbook:version:1.4.4 version:1.4.4")
                end
                def test_escaped_redmine_links_should_not_be_parsed
                  to_test = [
                    '#3.',
                    '#3-14.',
                    '#3#-note14.',
                    'r1',
                    'document#1',
                    'document:"Test document"',
                    'version#2',
                    'version:1.0',
                    'version:"1.0"',
                    'source:/some/file'
                  ]
                  @project = Project.find(1)
                  to_test.each { |text| assert_equal "<p>#{text}</p>", textilizable("!" + text), "#{text} failed" }
                end
                def test_cross_project_redmine_links
                  source_link = link_to('ecookbook:source:/some/file',
                                        {:controller => 'repositories', :action => 'entry',
                                         :id => 'ecookbook', :path => ['some', 'file']},
                                        :class => 'source')
                  changeset_link = link_to('ecookbook:r2',
                                           {:controller => 'repositories', :action => 'revision',
                                            :id => 'ecookbook', :rev => 2},
                                           :class => 'changeset',
                                           :title => 'This commit fixes #1, #2 and references #1 & #3')
                  to_test = {
                    # documents
                    'document:"Test document"'              => 'document:"Test document"',
                    'ecookbook:document:"Test document"'    =>
                        link_to("Test document", "/documents/1", :class => "document"),
                    'invalid:document:"Test document"'      => 'invalid:document:"Test document"',
                    # versions
                    'version:"1.0"'                         => 'version:"1.0"',
                    'ecookbook:version:"1.0"'               =>
                        link_to("1.0", "/versions/2", :class => "version"),
                    'invalid:version:"1.0"'                 => 'invalid:version:"1.0"',
                    # changeset
                    'r2'                                    => 'r2',
                    'ecookbook:r2'                          => changeset_link,
                    'invalid:r2'                            => 'invalid:r2',
                    # source
                    'source:/some/file'                     => 'source:/some/file',
                    'ecookbook:source:/some/file'           => source_link,
                    'invalid:source:/some/file'             => 'invalid:source:/some/file',
                  }
                  @project = Project.find(3)
                  to_test.each do |text, result|
                    assert_equal "<p>#{result}</p>", textilizable(text), "#{text} failed"
                  end
                end
                def test_redmine_links_by_name_should_work_with_html_escaped_characters
                  v = Version.generate!(:name => "Test & Show.txt", :project_id => 1)
                  link = link_to("Test & Show.txt", "/versions/#{v.id}", :class => "version")
                  @project = v.project
                  assert_equal "<p>#{link}</p>", textilizable('version:"Test & Show.txt"')
                end
                def test_link_to_issue_subject
                  issue = Issue.generate!(:subject => "01234567890123456789")
                  str = link_to_issue(issue, :truncate => 10)
                  result = link_to("Bug ##{issue.id}", "/issues/#{issue.id}", :class => issue.css_classes)
                  assert_equal "#{result}: 0123456...", str
                  issue = Issue.generate!(:subject => "<&>")
                  str = link_to_issue(issue)
                  result = link_to("Bug ##{issue.id}", "/issues/#{issue.id}", :class => issue.css_classes)
                  assert_equal "#{result}: &lt;&amp;&gt;", str
                  issue = Issue.generate!(:subject => "<&>0123456789012345")
                  str = link_to_issue(issue, :truncate => 10)
                  result = link_to("Bug ##{issue.id}", "/issues/#{issue.id}", :class => issue.css_classes)
                  assert_equal "#{result}: &lt;&amp;&gt;0123...", str
                end
                def test_link_to_issue_title
                  long_str = "0123456789" * 5
                  issue = Issue.generate!(:subject => "#{long_str}01234567890123456789")
                  str = link_to_issue(issue, :subject => false)
                  result = link_to("Bug ##{issue.id}", "/issues/#{issue.id}",
                                   :class => issue.css_classes,
                                   :title => "#{long_str}0123456...")
                  assert_equal result, str
                  issue = Issue.generate!(:subject => "<&>#{long_str}01234567890123456789")
                  str = link_to_issue(issue, :subject => false)
                  result = link_to("Bug ##{issue.id}", "/issues/#{issue.id}",
                                   :class => issue.css_classes,
                                   :title => "<&>#{long_str}0123...")
                  assert_equal result, str
                end
                def test_multiple_repositories_redmine_links
                  svn = Repository::Subversion.create!(:project_id => 1, :identifier => 'svn_repo-1', :url => 'file:///foo/hg')
                  Changeset.create!(:repository => svn, :committed_on => Time.now, :revision => '123')
                  hg = Repository::Mercurial.create!(:project_id => 1, :identifier => 'hg1', :url => '/foo/hg')
                  Changeset.create!(:repository => hg, :committed_on => Time.now, :revision => '123', :scmid => 'abcd')
                  changeset_link = link_to('r2', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :rev => 2},
                                                  :class => 'changeset', :title => 'This commit fixes #1, #2 and references #1 & #3')
                  svn_changeset_link = link_to('svn_repo-1|r123', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :repository_id => 'svn_repo-1', :rev => 123},
                                                  :class => 'changeset', :title => '')
                  hg_changeset_link = link_to('hg1|abcd', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :repository_id => 'hg1', :rev => 'abcd'},
                                                  :class => 'changeset', :title => '')
                  source_link = link_to('source:some/file', {:controller => 'repositories', :action => 'entry', :id => 'ecookbook', :path => ['some', 'file']}, :class => 'source')
                  hg_source_link = link_to('source:hg1|some/file', {:controller => 'repositories', :action => 'entry', :id => 'ecookbook', :repository_id => 'hg1', :path => ['some', 'file']}, :class => 'source')
                  to_test = {
                    'r2'                          => changeset_link,
                    'svn_repo-1|r123'             => svn_changeset_link,
                    'invalid|r123'                => 'invalid|r123',
                    'commit:hg1|abcd'             => hg_changeset_link,
                    'commit:invalid|abcd'         => 'commit:invalid|abcd',
                    # source
                    'source:some/file'            => source_link,
                    'source:hg1|some/file'        => hg_source_link,
                    'source:invalid|some/file'    => 'source:invalid|some/file',
                  }
                  @project = Project.find(1)
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text), "#{text} failed" }
                end
                def test_cross_project_multiple_repositories_redmine_links
                  svn = Repository::Subversion.create!(:project_id => 1, :identifier => 'svn1', :url => 'file:///foo/hg')
                  Changeset.create!(:repository => svn, :committed_on => Time.now, :revision => '123')
                  hg = Repository::Mercurial.create!(:project_id => 1, :identifier => 'hg1', :url => '/foo/hg')
                  Changeset.create!(:repository => hg, :committed_on => Time.now, :revision => '123', :scmid => 'abcd')
                  changeset_link = link_to('ecookbook:r2', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :rev => 2},
                                                  :class => 'changeset', :title => 'This commit fixes #1, #2 and references #1 & #3')
                  svn_changeset_link = link_to('ecookbook:svn1|r123', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :repository_id => 'svn1', :rev => 123},
                                                  :class => 'changeset', :title => '')
                  hg_changeset_link = link_to('ecookbook:hg1|abcd', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :repository_id => 'hg1', :rev => 'abcd'},
                                                  :class => 'changeset', :title => '')
                  source_link = link_to('ecookbook:source:some/file', {:controller => 'repositories', :action => 'entry', :id => 'ecookbook', :path => ['some', 'file']}, :class => 'source')
                  hg_source_link = link_to('ecookbook:source:hg1|some/file', {:controller => 'repositories', :action => 'entry', :id => 'ecookbook', :repository_id => 'hg1', :path => ['some', 'file']}, :class => 'source')
                  to_test = {
                    'ecookbook:r2'                           => changeset_link,
                    'ecookbook:svn1|r123'                    => svn_changeset_link,
                    'ecookbook:invalid|r123'                 => 'ecookbook:invalid|r123',
                    'ecookbook:commit:hg1|abcd'              => hg_changeset_link,
                    'ecookbook:commit:invalid|abcd'          => 'ecookbook:commit:invalid|abcd',
                    'invalid:commit:invalid|abcd'            => 'invalid:commit:invalid|abcd',
                    # source
                    'ecookbook:source:some/file'             => source_link,
                    'ecookbook:source:hg1|some/file'         => hg_source_link,
                    'ecookbook:source:invalid|some/file'     => 'ecookbook:source:invalid|some/file',
                    'invalid:source:invalid|some/file'       => 'invalid:source:invalid|some/file',
                  }
                  @project = Project.find(3)
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text), "#{text} failed" }
                end
                def test_redmine_links_git_commit
                  changeset_link = link_to('abcd',
                                             {
                                               :controller => 'repositories',
                                               :action     => 'revision',
                                               :id         => 'subproject1',
                                               :rev        => 'abcd',
                                              },
                                            :class => 'changeset', :title => 'test commit')
                  to_test = {
                    'commit:abcd' => changeset_link,
                   }
                  @project = Project.find(3)
                  r = Repository::Git.create!(:project => @project, :url => '/tmp/test/git')
                  assert r
                  c = Changeset.new(:repository => r,
                                    :committed_on => Time.now,
                                    :revision => 'abcd',
                                    :scmid => 'abcd',
                                    :comments => 'test commit')
                  assert( c.save )
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                end
                # TODO: Bazaar commit id contains mail address, so it contains '@' and '_'.
                def test_redmine_links_darcs_commit
                  changeset_link = link_to('20080308225258-98289-abcd456efg.gz',
                                             {
                                               :controller => 'repositories',
                                               :action     => 'revision',
                                               :id         => 'subproject1',
                                               :rev        => '123',
                                              },
                                            :class => 'changeset', :title => 'test commit')
                  to_test = {
                    'commit:20080308225258-98289-abcd456efg.gz' => changeset_link,
                   }
                  @project = Project.find(3)
                  r = Repository::Darcs.create!(
                          :project => @project, :url => '/tmp/test/darcs',
                          :log_encoding => 'UTF-8')
                  assert r
                  c = Changeset.new(:repository => r,
                                    :committed_on => Time.now,
                                    :revision => '123',
                                    :scmid => '20080308225258-98289-abcd456efg.gz',
                                    :comments => 'test commit')
                  assert( c.save )
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                end
                def test_redmine_links_mercurial_commit
                  changeset_link_rev = link_to('r123',
                                                {
                                                   :controller => 'repositories',
                                                   :action     => 'revision',
                                                   :id         => 'subproject1',
                                                   :rev        => '123' ,
                                                },
                                            :class => 'changeset', :title => 'test commit')
                  changeset_link_commit = link_to('abcd',
                                                {
                                                      :controller => 'repositories',
                                                      :action     => 'revision',
                                                      :id         => 'subproject1',
                                                      :rev        => 'abcd' ,
                                                },
                                            :class => 'changeset', :title => 'test commit')
                  to_test = {
                    'r123' => changeset_link_rev,
                    'commit:abcd' => changeset_link_commit,
                   }
                  @project = Project.find(3)
                  r = Repository::Mercurial.create!(:project => @project, :url => '/tmp/test')
                  assert r
                  c = Changeset.new(:repository => r,
                                    :committed_on => Time.now,
                                    :revision => '123',
                                    :scmid => 'abcd',
                                    :comments => 'test commit')
                  assert( c.save )
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                end
                def test_attachment_links
                  text = 'attachment:error281.txt'
                  result = link_to("error281.txt", "/attachments/download/1/error281.txt",
                                   :class => "attachment")
                  assert_equal "<p>#{result}</p>",
                               textilizable(text,
                                            :attachments => Issue.find(3).attachments),
                               "#{text} failed"
                end
                def test_attachment_link_should_link_to_latest_attachment
                  set_tmp_attachments_directory
                  a1 = Attachment.generate!(:filename => "test.txt", :created_on => 1.hour.ago)
                  a2 = Attachment.generate!(:filename => "test.txt")
                  result = link_to("test.txt", "/attachments/download/#{a2.id}/test.txt",
                                   :class => "attachment")
                  assert_equal "<p>#{result}</p>",
                               textilizable('attachment:test.txt', :attachments => [a1, a2])
                end
                def test_wiki_links
                  russian_eacape = CGI.escape(@russian_test)
                  to_test = {
                    '[[CookBook documentation]]' =>
                        link_to("CookBook documentation",
                                "/projects/ecookbook/wiki/CookBook_documentation",
                                :class => "wiki-page"),
                    '[[Another page|Page]]' =>
                        link_to("Page",
                                "/projects/ecookbook/wiki/Another_page",
                                :class => "wiki-page"),
                    # title content should be formatted
                    '[[Another page|With _styled_ *title*]]' =>
                        link_to("With <em>styled</em> <strong>title</strong>".html_safe,
                                "/projects/ecookbook/wiki/Another_page",
                                :class => "wiki-page"),
                    '[[Another page|With title containing <strong>HTML entities &amp; markups</strong>]]' =>
                        link_to("With title containing &lt;strong&gt;HTML entities &amp; markups&lt;/strong&gt;".html_safe,
                                "/projects/ecookbook/wiki/Another_page",
                                :class => "wiki-page"),
                    # link with anchor
                    '[[CookBook documentation#One-section]]' =>
                        link_to("CookBook documentation",
                                "/projects/ecookbook/wiki/CookBook_documentation#One-section",
                                :class => "wiki-page"),
                    '[[Another page#anchor|Page]]' =>
                        link_to("Page",
                                "/projects/ecookbook/wiki/Another_page#anchor",
                                :class => "wiki-page"),
                    # UTF8 anchor
                    "[[Another_page##{@russian_test}|#{@russian_test}]]" =>
                        link_to(@russian_test,
                                "/projects/ecookbook/wiki/Another_page##{russian_eacape}",
                                :class => "wiki-page"),
                    # page that doesn't exist
                    '[[Unknown page]]' =>
                        link_to("Unknown page",
                                "/projects/ecookbook/wiki/Unknown_page",
                                :class => "wiki-page new"),
                    '[[Unknown page|404]]' =>
                        link_to("404",
                                "/projects/ecookbook/wiki/Unknown_page",
                                :class => "wiki-page new"),
                    # link to another project wiki
                    '[[onlinestore:]]' =>
                        link_to("onlinestore",
                                "/projects/onlinestore/wiki",
                                :class => "wiki-page"),
                    '[[onlinestore:|Wiki]]' =>
                        link_to("Wiki",
                                "/projects/onlinestore/wiki",
                                :class => "wiki-page"),
                    '[[onlinestore:Start page]]' =>
                        link_to("Start page",
                                "/projects/onlinestore/wiki/Start_page",
                                :class => "wiki-page"),
                    '[[onlinestore:Start page|Text]]' =>
                        link_to("Text",
                                "/projects/onlinestore/wiki/Start_page",
                                :class => "wiki-page"),
                    '[[onlinestore:Unknown page]]' =>
                        link_to("Unknown page",
                                "/projects/onlinestore/wiki/Unknown_page",
                                :class => "wiki-page new"),
                    # struck through link
                    '-[[Another page|Page]]-' =>
                        "<del>".html_safe +
                          link_to("Page",
                                  "/projects/ecookbook/wiki/Another_page",
                                  :class => "wiki-page").html_safe +
                          "</del>".html_safe,
                    '-[[Another page|Page]] link-' =>
                        "<del>".html_safe +
                          link_to("Page",
                                  "/projects/ecookbook/wiki/Another_page",
                                  :class => "wiki-page").html_safe +
                          " link</del>".html_safe,
                    # escaping
                    '![[Another page|Page]]' => '[[Another page|Page]]',
                    # project does not exist
                    '[[unknowproject:Start]]' => '[[unknowproject:Start]]',
                    '[[unknowproject:Start|Page title]]' => '[[unknowproject:Start|Page title]]',
                  }
                  @project = Project.find(1)
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                end
                def test_wiki_links_within_local_file_generation_context
                  to_test = {
                    # link to a page
                    '[[CookBook documentation]]' =>
                       link_to("CookBook documentation", "CookBook_documentation.html",
                               :class => "wiki-page"),
                    '[[CookBook documentation|documentation]]' =>
                       link_to("documentation", "CookBook_documentation.html",
                               :class => "wiki-page"),
                    '[[CookBook documentation#One-section]]' =>
                       link_to("CookBook documentation", "CookBook_documentation.html#One-section",
                               :class => "wiki-page"),
                    '[[CookBook documentation#One-section|documentation]]' =>
                       link_to("documentation", "CookBook_documentation.html#One-section",
                               :class => "wiki-page"),
                    # page that doesn't exist
                    '[[Unknown page]]' =>
                       link_to("Unknown page", "Unknown_page.html",
                               :class => "wiki-page new"),
                    '[[Unknown page|404]]' =>
                       link_to("404", "Unknown_page.html",
                               :class => "wiki-page new"),
                    '[[Unknown page#anchor]]' =>
                       link_to("Unknown page", "Unknown_page.html#anchor",
                               :class => "wiki-page new"),
                    '[[Unknown page#anchor|404]]' =>
                       link_to("404", "Unknown_page.html#anchor",
                               :class => "wiki-page new"),
                  }
                  @project = Project.find(1)
                  to_test.each do |text, result|
                    assert_equal "<p>#{result}</p>", textilizable(text, :wiki_links => :local)
                  end
                end
                def test_wiki_links_within_wiki_page_context
                  page = WikiPage.find_by_title('Another_page' )
                  to_test = {
                    '[[CookBook documentation]]' =>
                       link_to("CookBook documentation",
                               "/projects/ecookbook/wiki/CookBook_documentation",
                               :class => "wiki-page"),
                    '[[CookBook documentation|documentation]]' =>
                       link_to("documentation",
                               "/projects/ecookbook/wiki/CookBook_documentation",
                               :class => "wiki-page"),
                    '[[CookBook documentation#One-section]]' =>
                       link_to("CookBook documentation",
                               "/projects/ecookbook/wiki/CookBook_documentation#One-section",
                               :class => "wiki-page"),
                    '[[CookBook documentation#One-section|documentation]]' =>
                       link_to("documentation",
                               "/projects/ecookbook/wiki/CookBook_documentation#One-section",
                               :class => "wiki-page"),
                    # link to the current page
                    '[[Another page]]' =>
                       link_to("Another page",
                               "/projects/ecookbook/wiki/Another_page",
                               :class => "wiki-page"),
                    '[[Another page|Page]]' =>
                       link_to("Page",
                               "/projects/ecookbook/wiki/Another_page",
                               :class => "wiki-page"),
                    '[[Another page#anchor]]' =>
                       link_to("Another page",
                               "#anchor",
                               :class => "wiki-page"),
                    '[[Another page#anchor|Page]]' =>
                       link_to("Page",
                               "#anchor",
                               :class => "wiki-page"),
                    # page that doesn't exist
                    '[[Unknown page]]' =>
                       link_to("Unknown page",
                               "/projects/ecookbook/wiki/Unknown_page?parent=Another_page",
                               :class => "wiki-page new"),
                    '[[Unknown page|404]]' =>
                       link_to("404",
                               "/projects/ecookbook/wiki/Unknown_page?parent=Another_page",
                               :class => "wiki-page new"),
                    '[[Unknown page#anchor]]' =>
                       link_to("Unknown page",
                               "/projects/ecookbook/wiki/Unknown_page?parent=Another_page#anchor",
                               :class => "wiki-page new"),
                    '[[Unknown page#anchor|404]]' =>
                       link_to("404",
                               "/projects/ecookbook/wiki/Unknown_page?parent=Another_page#anchor",
                               :class => "wiki-page new"),
                  }
                  @project = Project.find(1)
                  to_test.each do |text, result|
                    assert_equal "<p>#{result}</p>",
                                 textilizable(WikiContent.new( :text => text, :page => page ), :text)
                  end
                end
                def test_wiki_links_anchor_option_should_prepend_page_title_to_href
                  to_test = {
                    # link to a page
                    '[[CookBook documentation]]' =>
                        link_to("CookBook documentation",
                                "#CookBook_documentation",
                                :class => "wiki-page"),
                    '[[CookBook documentation|documentation]]' =>
                        link_to("documentation",
                                "#CookBook_documentation",
                                :class => "wiki-page"),
                    '[[CookBook documentation#One-section]]' =>
                        link_to("CookBook documentation",
                                "#CookBook_documentation_One-section",
                                :class => "wiki-page"),
                    '[[CookBook documentation#One-section|documentation]]' =>
                        link_to("documentation",
                                "#CookBook_documentation_One-section",
                                :class => "wiki-page"),
                    # page that doesn't exist
                    '[[Unknown page]]' =>
                        link_to("Unknown page",
                                "#Unknown_page",
                                :class => "wiki-page new"),
                    '[[Unknown page|404]]' =>
                        link_to("404",
                                "#Unknown_page",
                                :class => "wiki-page new"),
                    '[[Unknown page#anchor]]' =>
                        link_to("Unknown page",
                                "#Unknown_page_anchor",
                                :class => "wiki-page new"),
                    '[[Unknown page#anchor|404]]' =>
                        link_to("404",
                                "#Unknown_page_anchor",
                                :class => "wiki-page new"),
                  }
                  @project = Project.find(1)
                  to_test.each do |text, result|
                    assert_equal "<p>#{result}</p>", textilizable(text, :wiki_links => :anchor)
                  end
                end
                def test_html_tags
                  to_test = {
                    "<div>content</div>" => "<p>&lt;div&gt;content&lt;/div&gt;</p>",
                    "<div class=\"bold\">content</div>" => "<p>&lt;div class=\"bold\"&gt;content&lt;/div&gt;</p>",
                    "<script>some script;</script>" => "<p>&lt;script&gt;some script;&lt;/script&gt;</p>",
                    # do not escape pre/code tags
                    "<pre>\nline 1\nline2</pre>" => "<pre>\nline 1\nline2</pre>",
                    "<pre><code>\nline 1\nline2</code></pre>" => "<pre><code>\nline 1\nline2</code></pre>",
                    "<pre><div>content</div></pre>" => "<pre>&lt;div&gt;content&lt;/div&gt;</pre>",
                    "HTML comment: <!-- no comments -->" => "<p>HTML comment: &lt;!-- no comments --&gt;</p>",
                    "<!-- opening comment" => "<p>&lt;!-- opening comment</p>",
                    # remove attributes except class
                    "<pre class='foo'>some text</pre>" => "<pre class='foo'>some text</pre>",
                    '<pre class="foo">some text</pre>' => '<pre class="foo">some text</pre>',
                    "<pre class='foo bar'>some text</pre>" => "<pre class='foo bar'>some text</pre>",
                    '<pre class="foo bar">some text</pre>' => '<pre class="foo bar">some text</pre>',
                    "<pre onmouseover='alert(1)'>some text</pre>" => "<pre>some text</pre>",
                    # xss
                    '<pre><code class=""onmouseover="alert(1)">text</code></pre>' => '<pre><code>text</code></pre>',
                    '<pre class=""onmouseover="alert(1)">text</pre>' => '<pre>text</pre>',
                  }
                  to_test.each { |text, result| assert_equal result, textilizable(text) }
                end
                def test_allowed_html_tags
                  to_test = {
                    "<pre>preformatted text</pre>" => "<pre>preformatted text</pre>",
                    "<notextile>no *textile* formatting</notextile>" => "no *textile* formatting",
                    "<notextile>this is <tag>a tag</tag></notextile>" => "this is &lt;tag&gt;a tag&lt;/tag&gt;"
                  }
                  to_test.each { |text, result| assert_equal result, textilizable(text) }
                end
                def test_pre_tags
                  raw = <<-RAW
              Before
              <pre>
              <prepared-statement-cache-size>32</prepared-statement-cache-size>
              </pre>
              After
              RAW
                  expected = <<-EXPECTED
              <p>Before</p>
              <pre>
              &lt;prepared-statement-cache-size&gt;32&lt;/prepared-statement-cache-size&gt;
              </pre>
              <p>After</p>
              EXPECTED
                  assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(raw).gsub(%r{[\r\n\t]}, '')
                end
                def test_pre_content_should_not_parse_wiki_and_redmine_links
                  raw = <<-RAW
              [[CookBook documentation]]
              #1
              <pre>
              [[CookBook documentation]]
              #1
              </pre>
              RAW
                  result1 = link_to("CookBook documentation",
                                    "/projects/ecookbook/wiki/CookBook_documentation",
                                    :class => "wiki-page")
                  result2 = link_to('#1',
                                    "/issues/1",
                                    :class => Issue.find(1).css_classes,
                                    :title => "Bug: Cannot print recipes (New)")
                  expected = <<-EXPECTED
              <p>#{result1}</p>
              <p>#{result2}</p>
              <pre>
              [[CookBook documentation]]
              #1
              </pre>
              EXPECTED
                  @project = Project.find(1)
                  assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(raw).gsub(%r{[\r\n\t]}, '')
                end
                def test_non_closing_pre_blocks_should_be_closed
                  raw = <<-RAW
              <pre><code>
              RAW
                  expected = <<-EXPECTED
              <pre><code>
              </code></pre>
              EXPECTED
                  @project = Project.find(1)
                  assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(raw).gsub(%r{[\r\n\t]}, '')
                end
                def test_unbalanced_closing_pre_tag_should_not_error
                  assert_nothing_raised do
                    textilizable("unbalanced</pre>")
                  end
                end
                def test_syntax_highlight
                  raw = <<-RAW
              <pre><code class="ruby">
              # Some ruby code here
              </code></pre>
              RAW
                  expected = <<-EXPECTED
              <pre><code class="ruby syntaxhl"><span class=\"CodeRay\"><span class="comment"># Some ruby code here</span></span>
              </code></pre>
              EXPECTED
                  assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(raw).gsub(%r{[\r\n\t]}, '')
                end
                def test_to_path_param
                  assert_equal 'test1/test2', to_path_param('test1/test2')
                  assert_equal 'test1/test2', to_path_param('/test1/test2/')
                  assert_equal 'test1/test2', to_path_param('//test1/test2/')
-                 assert_equal nil, to_path_param('/')
+                 assert_nil to_path_param('/')
                end
                def test_wiki_links_in_tables
                  text = "|[[Page|Link title]]|[[Other Page|Other title]]|\n|Cell 21|[[Last page]]|"
                  link1 = link_to("Link title", "/projects/ecookbook/wiki/Page", :class => "wiki-page new")
                  link2 = link_to("Other title", "/projects/ecookbook/wiki/Other_Page", :class => "wiki-page new")
                  link3 = link_to("Last page", "/projects/ecookbook/wiki/Last_page", :class => "wiki-page new")
                  result = "<tr><td>#{link1}</td>" +
                             "<td>#{link2}</td>" +
                             "</tr><tr><td>Cell 21</td><td>#{link3}</td></tr>"
                  @project = Project.find(1)
                  assert_equal "<table>#{result}</table>", textilizable(text).gsub(/[\t\n]/, '')
                end
                def test_text_formatting
                  to_test = {'*_+bold, italic and underline+_*' => '<strong><em><ins>bold, italic and underline</ins></em></strong>',
                             '(_text within parentheses_)' => '(<em>text within parentheses</em>)',
                             'a *Humane Web* Text Generator' => 'a <strong>Humane Web</strong> Text Generator',
                             'a H *umane* W *eb* T *ext* G *enerator*' => 'a H <strong>umane</strong> W <strong>eb</strong> T <strong>ext</strong> G <strong>enerator</strong>',
                             'a *H* umane *W* eb *T* ext *G* enerator' => 'a <strong>H</strong> umane <strong>W</strong> eb <strong>T</strong> ext <strong>G</strong> enerator',
                            }
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                end
                def test_wiki_horizontal_rule
                  assert_equal '<hr />', textilizable('---')
                  assert_equal '<p>Dashes: ---</p>', textilizable('Dashes: ---')
                end
                def test_footnotes
                  raw = <<-RAW
              This is some text[1].
              fn1. This is the foot note
              RAW
                  expected = <<-EXPECTED
              <p>This is some text<sup><a href=\"#fn1\">1</a></sup>.</p>
              <p id="fn1" class="footnote"><sup>1</sup> This is the foot note</p>
              EXPECTED
                  assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(raw).gsub(%r{[\r\n\t]}, '')
                end
                def test_headings
                  raw = 'h1. Some heading'
                  expected = %|<a name="Some-heading"></a>\n<h1 >Some heading<a href="#Some-heading" class="wiki-anchor">&para;</a></h1>|
                  assert_equal expected, textilizable(raw)
                end
                def test_headings_with_special_chars
                  # This test makes sure that the generated anchor names match the expected
                  # ones even if the heading text contains unconventional characters
                  raw = 'h1. Some heading related to version 0.5'
                  anchor = sanitize_anchor_name("Some-heading-related-to-version-0.5")
                  expected = %|<a name="#{anchor}"></a>\n<h1 >Some heading related to version 0.5<a href="##{anchor}" class="wiki-anchor">&para;</a></h1>|
                  assert_equal expected, textilizable(raw)
                end
                def test_headings_in_wiki_single_page_export_should_be_prepended_with_page_title
                  page = WikiPage.new( :title => 'Page Title', :wiki_id => 1 )
                  content = WikiContent.new( :text => 'h1. Some heading', :page => page )
                  expected = %|<a name="Page_Title_Some-heading"></a>\n<h1 >Some heading<a href="#Page_Title_Some-heading" class="wiki-anchor">&para;</a></h1>|
                  assert_equal expected, textilizable(content, :text, :wiki_links => :anchor )
                end
                def test_table_of_content
                  set_language_if_valid 'en'
                  raw = <<-RAW
              {{toc}}
              h1. Title
              Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas sed libero.
              h2. Subtitle with a [[Wiki]] link
              Nullam commodo metus accumsan nulla. Curabitur lobortis dui id dolor.
              h2. Subtitle with [[Wiki|another Wiki]] link
              h2. Subtitle with %{color:red}red text%
              <pre>
              some code
              </pre>
              h3. Subtitle with *some* _modifiers_
              h3. Subtitle with @inline code@
              h1. Another title
              h3. An "Internet link":http://www.redmine.org/ inside subtitle
              h2. "Project Name !/attachments/1234/logo_small.gif! !/attachments/5678/logo_2.png!":/projects/projectname/issues
              RAW
                  expected =  '<ul class="toc">' +
                                '<li><strong>Table of contents</strong></li>' +
                                '<li><a href="#Title">Title</a>' +
                                  '<ul>' +
                                    '<li><a href="#Subtitle-with-a-Wiki-link">Subtitle with a Wiki link</a></li>' +
                                    '<li><a href="#Subtitle-with-another-Wiki-link">Subtitle with another Wiki link</a></li>' +
                                    '<li><a href="#Subtitle-with-red-text">Subtitle with red text</a>' +
                                      '<ul>' +
                                        '<li><a href="#Subtitle-with-some-modifiers">Subtitle with some modifiers</a></li>' +
                                        '<li><a href="#Subtitle-with-inline-code">Subtitle with inline code</a></li>' +
                                      '</ul>' +
                                    '</li>' +
                                  '</ul>' +
                                '</li>' +
                                '<li><a href="#Another-title">Another title</a>' +
                                  '<ul>' +
                                    '<li>' +
                                      '<ul>' +
                                        '<li><a href="#An-Internet-link-inside-subtitle">An Internet link inside subtitle</a></li>' +
                                      '</ul>' +
                                    '</li>' +
                                    '<li><a href="#Project-Name">Project Name</a></li>' +
                                  '</ul>' +
                                '</li>' +
                             '</ul>'
                  @project = Project.find(1)
                  assert textilizable(raw).gsub("\n", "").include?(expected)
                end
                def test_table_of_content_should_generate_unique_anchors
                  set_language_if_valid 'en'
                  raw = <<-RAW
              {{toc}}
              h1. Title
              h2. Subtitle
              h2. Subtitle
              RAW
                  expected =  '<ul class="toc">' +
                                '<li><strong>Table of contents</strong></li>' +
                                '<li><a href="#Title">Title</a>' +
                                  '<ul>' +
                                    '<li><a href="#Subtitle">Subtitle</a></li>' +
                                    '<li><a href="#Subtitle-2">Subtitle</a></li>' +
                                  '</ul>' +
                                '</li>' +
                              '</ul>'
                  @project = Project.find(1)
                  result = textilizable(raw).gsub("\n", "")
                  assert_include expected, result
                  assert_include '<a name="Subtitle">', result
                  assert_include '<a name="Subtitle-2">', result
                end
                def test_table_of_content_should_contain_included_page_headings
                  set_language_if_valid 'en'
                  raw = <<-RAW
              {{toc}}
              h1. Included
              {{include(Child_1)}}
              RAW
                  expected = '<ul class="toc">' +
                             '<li><strong>Table of contents</strong></li>' +
                             '<li><a href="#Included">Included</a></li>' +
                             '<li><a href="#Child-page-1">Child page 1</a></li>' +
                             '</ul>'
                  @project = Project.find(1)
                  assert textilizable(raw).gsub("\n", "").include?(expected)
                end
                def test_toc_with_textile_formatting_should_be_parsed
                  with_settings :text_formatting => 'textile' do
                    assert_select_in textilizable("{{toc}}\n\nh1. Heading"), 'ul.toc li', :text => 'Heading'
                    assert_select_in textilizable("{{<toc}}\n\nh1. Heading"), 'ul.toc.left li', :text => 'Heading'
                    assert_select_in textilizable("{{>toc}}\n\nh1. Heading"), 'ul.toc.right li', :text => 'Heading'
                  end
                end
                if Object.const_defined?(:Redcarpet)
                def test_toc_with_markdown_formatting_should_be_parsed
                  with_settings :text_formatting => 'markdown' do
                    assert_select_in textilizable("{{toc}}\n\n# Heading"), 'ul.toc li', :text => 'Heading'
                    assert_select_in textilizable("{{<toc}}\n\n# Heading"), 'ul.toc.left li', :text => 'Heading'
                    assert_select_in textilizable("{{>toc}}\n\n# Heading"), 'ul.toc.right li', :text => 'Heading'
                  end
                end
                end
                def test_section_edit_links
                  raw = <<-RAW
              h1. Title
              Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas sed libero.
              h2. Subtitle with a [[Wiki]] link
              h2. Subtitle with *some* _modifiers_
              h2. Subtitle with @inline code@
              <pre>
              some code
              h2. heading inside pre
              <h2>html heading inside pre</h2>
              </pre>
              h2. Subtitle after pre tag
              RAW
                  @project = Project.find(1)
                  set_language_if_valid 'en'
                  result = textilizable(raw, :edit_section_links => {:controller => 'wiki', :action => 'edit', :project_id => '1', :id => 'Test'}).gsub("\n", "")
                  # heading that contains inline code
                  assert_match Regexp.new('<div class="contextual heading-2" title="Edit this section" id="section-4">' +
                    '<a class="icon-only icon-edit" href="/projects/1/wiki/Test/edit\?section=4">Edit this section</a></div>' +
                    '<a name="Subtitle-with-inline-code"></a>' +
                    '<h2 >Subtitle with <code>inline code</code><a href="#Subtitle-with-inline-code" class="wiki-anchor">&para;</a></h2>'),
                    result
                  # last heading
                  assert_match Regexp.new('<div class="contextual heading-2" title="Edit this section" id="section-5">' +
                    '<a class="icon-only icon-edit" href="/projects/1/wiki/Test/edit\?section=5">Edit this section</a></div>' +
                    '<a name="Subtitle-after-pre-tag"></a>' +
                    '<h2 >Subtitle after pre tag<a href="#Subtitle-after-pre-tag" class="wiki-anchor">&para;</a></h2>'),
                    result
                end
                def test_default_formatter
                  with_settings :text_formatting => 'unknown' do
                    text = 'a *link*: http://www.example.net/'
                    assert_equal '<p>a *link*: <a class="external" href="http://www.example.net/">http://www.example.net/</a></p>', textilizable(text)
                  end
                end
                def test_parse_redmine_links_should_handle_a_tag_without_attributes
                  text = '<a>http://example.com</a>'
                  expected = text.dup
                  parse_redmine_links(text, nil, nil, nil, true, {})
                  assert_equal expected, text
                end
                def test_due_date_distance_in_words
                  to_test = { Date.today => 'Due in 0 days',
                              Date.today + 1 => 'Due in 1 day',
                              Date.today + 100 => 'Due in about 3 months',
                              Date.today + 20000 => 'Due in over 54 years',
                              Date.today - 1 => '1 day late',
                              Date.today - 100 => 'about 3 months late',
                              Date.today - 20000 => 'over 54 years late',
                             }
                  ::I18n.locale = :en
                  to_test.each do |date, expected|
                    assert_equal expected, due_date_distance_in_words(date)
                  end
                end
                def test_avatar_enabled
                  with_settings :gravatar_enabled => '1' do
                    assert avatar(User.find_by_mail('jsmith@somenet.foo')).include?(Digest::MD5.hexdigest('jsmith@somenet.foo'))
                    assert avatar('jsmith <jsmith@somenet.foo>').include?(Digest::MD5.hexdigest('jsmith@somenet.foo'))
                    # Default size is 50
                    assert avatar('jsmith <jsmith@somenet.foo>').include?('size=50')
                    assert avatar('jsmith <jsmith@somenet.foo>', :size => 24).include?('size=24')
                    # Non-avatar options should be considered html options
                    assert avatar('jsmith <jsmith@somenet.foo>', :title => 'John Smith').include?('title="John Smith"')
                    # The default class of the img tag should be gravatar
                    assert avatar('jsmith <jsmith@somenet.foo>').include?('class="gravatar"')
                    assert !avatar('jsmith <jsmith@somenet.foo>', :class => 'picture').include?('class="gravatar"')
                    assert_nil avatar('jsmith')
                    assert_nil avatar(nil)
                  end
                end
                def test_avatar_disabled
                  with_settings :gravatar_enabled => '0' do
                    assert_equal '', avatar(User.find_by_mail('jsmith@somenet.foo'))
                  end
                end
                def test_link_to_user
                  user = User.find(2)
                  result = link_to("John Smith", "/users/2", :class => "user active")
                  assert_equal result, link_to_user(user)
                end
                def test_link_to_user_should_not_link_to_locked_user
                  with_current_user nil do
                    user = User.find(5)
                    assert user.locked?
                    assert_equal 'Dave2 Lopper2', link_to_user(user)
                  end
                end
                def test_link_to_user_should_link_to_locked_user_if_current_user_is_admin
                  with_current_user User.find(1) do
                    user = User.find(5)
                    assert user.locked?
                    result = link_to("Dave2 Lopper2", "/users/5", :class => "user locked")
                    assert_equal result, link_to_user(user)
                  end
                end
                def test_link_to_user_should_not_link_to_anonymous
                  user = User.anonymous
                  assert user.anonymous?
                  t = link_to_user(user)
                  assert_equal ::I18n.t(:label_user_anonymous), t
                end
                def test_link_to_attachment
                  a = Attachment.find(3)
                  assert_equal '<a href="/attachments/3/logo.gif">logo.gif</a>',
                    link_to_attachment(a)
                  assert_equal '<a href="/attachments/3/logo.gif">Text</a>',
                    link_to_attachment(a, :text => 'Text')
                  result = link_to("logo.gif", "/attachments/3/logo.gif", :class => "foo")
                  assert_equal result,
                    link_to_attachment(a, :class => 'foo')
                  assert_equal '<a href="/attachments/download/3/logo.gif">logo.gif</a>',
                    link_to_attachment(a, :download => true)
                  assert_equal '<a href="http://test.host/attachments/3/logo.gif">logo.gif</a>',
                    link_to_attachment(a, :only_path => false)
                end
                def test_thumbnail_tag
                  a = Attachment.find(3)
                  assert_select_in thumbnail_tag(a),
                    'a[href=?][title=?] img[alt="3"][src=?]',
                    "/attachments/3/logo.gif", "logo.gif", "/attachments/thumbnail/3"
                end
                def test_link_to_project
                  project = Project.find(1)
                  assert_equal %(<a href="/projects/ecookbook">eCookbook</a>),
                               link_to_project(project)
                  assert_equal %(<a href="http://test.host/projects/ecookbook?jump=blah">eCookbook</a>),
                               link_to_project(project, {:only_path => false, :jump => 'blah'})
                end
                def test_link_to_project_settings
                  project = Project.find(1)
                  assert_equal '<a href="/projects/ecookbook/settings">eCookbook</a>', link_to_project_settings(project)
                  project.status = Project::STATUS_CLOSED
                  assert_equal '<a href="/projects/ecookbook">eCookbook</a>', link_to_project_settings(project)
                  project.status = Project::STATUS_ARCHIVED
                  assert_equal 'eCookbook', link_to_project_settings(project)
                end
                def test_link_to_legacy_project_with_numerical_identifier_should_use_id
                  # numeric identifier are no longer allowed
                  Project.where(:id => 1).update_all(:identifier => 25)
                  assert_equal '<a href="/projects/1">eCookbook</a>',
                               link_to_project(Project.find(1))
                end
                def test_principals_options_for_select_with_users
                  User.current = nil
                  users = [User.find(2), User.find(4)]
                  assert_equal %(<option value="2">John Smith</option><option value="4">Robert Hill</option>),
                    principals_options_for_select(users)
                end
                def test_principals_options_for_select_with_selected
                  User.current = nil
                  users = [User.find(2), User.find(4)]
                  assert_equal %(<option value="2">John Smith</option><option value="4" selected="selected">Robert Hill</option>),
                    principals_options_for_select(users, User.find(4))
                end
                def test_principals_options_for_select_with_users_and_groups
                  User.current = nil
                  set_language_if_valid 'en'
                  users = [User.find(2), Group.find(11), User.find(4), Group.find(10)]
                  assert_equal %(<option value="2">John Smith</option><option value="4">Robert Hill</option>) +
                    %(<optgroup label="Groups"><option value="10">A Team</option><option value="11">B Team</option></optgroup>),
                    principals_options_for_select(users)
                end
                def test_principals_options_for_select_with_empty_collection
                  assert_equal '', principals_options_for_select([])
                end
                def test_principals_options_for_select_should_include_me_option_when_current_user_is_in_collection
                  set_language_if_valid 'en'
                  users = [User.find(2), User.find(4)]
                  User.current = User.find(4)
                  assert_include '<option value="4">&lt;&lt; me &gt;&gt;</option>', principals_options_for_select(users)
                end
                def test_stylesheet_link_tag_should_pick_the_default_stylesheet
                  assert_match 'href="/stylesheets/styles.css"', stylesheet_link_tag("styles")
                end
                def test_stylesheet_link_tag_for_plugin_should_pick_the_plugin_stylesheet
                  assert_match 'href="/plugin_assets/foo/stylesheets/styles.css"', stylesheet_link_tag("styles", :plugin => :foo)
                end
                def test_image_tag_should_pick_the_default_image
                  assert_match 'src="/images/image.png"', image_tag("image.png")
                end
                def test_image_tag_should_pick_the_theme_image_if_it_exists
                  theme = Redmine::Themes.themes.last
                  theme.images << 'image.png'
                  with_settings :ui_theme => theme.id do
                    assert_match %|src="/themes/#{theme.dir}/images/image.png"|, image_tag("image.png")
                    assert_match %|src="/images/other.png"|, image_tag("other.png")
                  end
                ensure
                  theme.images.delete 'image.png'
                end
                def test_image_tag_sfor_plugin_should_pick_the_plugin_image
                  assert_match 'src="/plugin_assets/foo/images/image.png"', image_tag("image.png", :plugin => :foo)
                end
                def test_javascript_include_tag_should_pick_the_default_javascript
                  assert_match 'src="/javascripts/scripts.js"', javascript_include_tag("scripts")
                end
                def test_javascript_include_tag_for_plugin_should_pick_the_plugin_javascript
                  assert_match 'src="/plugin_assets/foo/javascripts/scripts.js"', javascript_include_tag("scripts", :plugin => :foo)
                end
                def test_raw_json_should_escape_closing_tags
                  s = raw_json(["<foo>bar</foo>"])
                  assert_include '\/foo', s
                end
                def test_raw_json_should_be_html_safe
                  s = raw_json(["foo"])
                  assert s.html_safe?
                end
                def test_html_title_should_app_title_if_not_set
                  assert_equal 'Redmine', html_title
                end
                def test_html_title_should_join_items
                  html_title 'Foo', 'Bar'
                  assert_equal 'Foo - Bar - Redmine', html_title
                end
                def test_html_title_should_append_current_project_name
                  @project = Project.find(1)
                  html_title 'Foo', 'Bar'
                  assert_equal 'Foo - Bar - eCookbook - Redmine', html_title
                end
                def test_title_should_return_a_h2_tag
                  assert_equal '<h2>Foo</h2>', title('Foo')
                end
                def test_title_should_set_html_title
                  title('Foo')
                  assert_equal 'Foo - Redmine', html_title
                end
                def test_title_should_turn_arrays_into_links
                  assert_equal '<h2><a href="/foo">Foo</a></h2>', title(['Foo', '/foo'])
                  assert_equal 'Foo - Redmine', html_title
                end
                def test_title_should_join_items
                  assert_equal '<h2>Foo &#187; Bar</h2>', title('Foo', 'Bar')
                  assert_equal 'Bar - Foo - Redmine', html_title
                end
                def test_favicon_path
                  assert_match %r{^/favicon\.ico}, favicon_path
                end
                def test_favicon_path_with_suburi
                  Redmine::Utils.relative_url_root = '/foo'
                  assert_match %r{^/foo/favicon\.ico}, favicon_path
                ensure
                  Redmine::Utils.relative_url_root = ''
                end
                def test_favicon_url
                  assert_match %r{^http://test\.host/favicon\.ico}, favicon_url
                end
                def test_favicon_url_with_suburi
                  Redmine::Utils.relative_url_root = '/foo'
                  assert_match %r{^http://test\.host/foo/favicon\.ico}, favicon_url
                ensure
                  Redmine::Utils.relative_url_root = ''
                end
                def test_truncate_single_line
                  str = "01234"
                  result = truncate_single_line_raw("#{str}\n#{str}", 10)
                  assert_equal "01234 0...", result
                  assert !result.html_safe?
                  result = truncate_single_line_raw("#{str}<&#>\n#{str}#{str}", 16)
                  assert_equal "01234<&#> 012...", result
                  assert !result.html_safe?
                end
                def test_truncate_single_line_non_ascii
                  ja = "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e".force_encoding('UTF-8')
                  result = truncate_single_line_raw("#{ja}\n#{ja}\n#{ja}", 10)
                  assert_equal "#{ja} #{ja}...", result
                  assert !result.html_safe?
                end
                def test_back_url_should_remove_utf8_checkmark_from_referer
                  stubs(:request).returns(stub(:env => {'HTTP_REFERER' => "/path?utf8=\u2713&foo=bar"}))
                  assert_equal "/path?foo=bar", back_url
                end
                def test_hours_formatting
                  set_language_if_valid 'en'
                  with_settings :timespan_format => 'minutes' do
                    assert_equal '0:45', format_hours(0.75)
                    assert_equal '0:45 h', l_hours_short(0.75)
                    assert_equal '0:45 hour', l_hours(0.75)
                  end
                  with_settings :timespan_format => 'decimal' do
                    assert_equal '0.75', format_hours(0.75)
                    assert_equal '0.75 h', l_hours_short(0.75)
                    assert_equal '0.75 hour', l_hours(0.75)
                  end
                end
                def test_html_hours
                  assert_equal '<span class="hours hours-int">0</span><span class="hours hours-dec">:45</span>', html_hours('0:45')
                  assert_equal '<span class="hours hours-int">0</span><span class="hours hours-dec">.75</span>', html_hours('0.75')
                end
              end

test/unit/issue_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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, :email_addresses, :user_preferences, :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 setup
                  set_language_if_valid 'en'
                end
                def teardown
                  User.current = nil
                end
                def test_initialize
                  issue = Issue.new
                  assert_nil issue.project_id
                  assert_nil issue.tracker_id
                  assert_nil issue.status_id
                  assert_nil issue.author_id
                  assert_nil issue.assigned_to_id
                  assert_nil issue.category_id
                  assert_equal IssuePriority.default, issue.priority
                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, :subject => 'test_create')
                  assert issue.save
                  assert_equal issue.tracker.default_status, issue.status
                  assert issue.description.nil?
                  assert_nil issue.estimated_hours
                end
                def test_create_with_all_fields_disabled
                  tracker = Tracker.find(1)
                  tracker.core_fields = []
                  tracker.save!
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :subject => 'test_create_with_all_fields_disabled')
                  assert_save issue
                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_start_date_lesser_than_soonest_start_should_not_validate_on_create
                  issue = Issue.generate(:start_date => '2013-06-04')
                  issue.stubs(:soonest_start).returns(Date.parse('2013-06-10'))
                  assert !issue.valid?
                  assert_include "Start date cannot be earlier than 06/10/2013 because of preceding issues", issue.errors.full_messages
                end
                def test_start_date_lesser_than_soonest_start_should_not_validate_on_update_if_changed
                  issue = Issue.generate!(:start_date => '2013-06-04')
                  issue.stubs(:soonest_start).returns(Date.parse('2013-06-10'))
                  issue.start_date = '2013-06-07'
                  assert !issue.valid?
                  assert_include "Start date cannot be earlier than 06/10/2013 because of preceding issues", issue.errors.full_messages
                end
                def test_start_date_lesser_than_soonest_start_should_validate_on_update_if_unchanged
                  issue = Issue.generate!(:start_date => '2013-06-04')
                  issue.stubs(:soonest_start).returns(Date.parse('2013-06-10'))
                  assert issue.valid?
                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!(: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 cannot be blank"], issue.errors.full_messages
                  # Blank value
                  issue.custom_field_values = { field.id => '' }
                  assert !issue.save
                  assert_equal ["Database cannot 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.order('id DESC').first
                    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).to_a
                  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).to_a
                  assert issues.empty?
                  assert_visibility_match User.anonymous, issues
                end
                def test_visible_scope_for_anonymous_without_view_issues_permissions_and_membership
                  Role.anonymous.remove_permission!(:view_issues)
                  Member.create!(:project_id => 1, :principal => Group.anonymous, :role_ids => [2])
                  issues = Issue.visible(User.anonymous).all
                  assert issues.any?
                  assert_equal [1], issues.map(&:project_id).uniq.sort
                  assert_visibility_match User.anonymous, issues
                end
                def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_default
                  Role.anonymous.update!(:issues_visibility => 'default')
                  issue = Issue.generate!(:author => 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!(:issues_visibility => 'own')
                  issue = Issue.generate!(:author => 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).to_a
                  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! :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).to_a
                  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).to_a
                  assert issues.empty?
                  assert_visibility_match user, issues
                end
                def test_visible_scope_for_non_member_without_view_issues_permissions_and_membership
                  Role.non_member.remove_permission!(:view_issues)
                  Member.create!(:project_id => 1, :principal => Group.non_member, :role_ids => [2])
                  user = User.find(9)
                  issues = Issue.visible(user).all
                  assert issues.any?
                  assert_equal [1], issues.map(&:project_id).uniq.sort
                  assert_visibility_match user, issues
                end
                def test_visible_scope_for_member
                  user = User.find(9)
                  # User should see issues of projects for which user 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).to_a
                  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_without_view_issues_permission_and_non_member_role_having_the_permission
                  Role.non_member.add_permission!(:view_issues)
                  Role.find(1).remove_permission!(:view_issues)
                  user = User.find(2)
                  assert_equal 0, Issue.where(:project_id => 1).visible(user).count
                  assert_equal false, Issue.where(:project_id => 1).first.visible?(user)
                end
                def test_visible_scope_with_custom_non_member_role_having_restricted_permission
                  role = Role.generate!(:permissions => [:view_project])
                  assert Role.non_member.has_permission?(:view_issues)
                  user = User.generate!
                  Member.create!(:principal => Group.non_member, :project_id => 1, :roles => [role])
                  issues = Issue.visible(user).to_a
                  assert issues.any?
                  assert_nil issues.detect {|issue| issue.project_id == 1}
                end
                def test_visible_scope_with_custom_non_member_role_having_extended_permission
                  role = Role.generate!(:permissions => [:view_project, :view_issues])
                  Role.non_member.remove_permission!(:view_issues)
                  user = User.generate!
                  Member.create!(:principal => Group.non_member, :project_id => 1, :roles => [role])
                  issues = Issue.visible(user).to_a
                  assert issues.any?
                  assert_not_nil issues.detect {|issue| issue.project_id == 1}
                end
                def test_visible_scope_for_member_with_groups_should_return_assigned_issues
                  user = User.find(8)
                  assert user.groups.any?
                  group = user.groups.first
                  Member.create!(:principal => group, :project_id => 1, :role_ids => [2])
                  Role.non_member.remove_permission!(:view_issues)
                  with_settings :issue_group_assignment => '1' do
                    issue = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 3,
                      :status_id => 1, :priority => IssuePriority.all.first,
                      :subject => 'Assignment test',
                      :assigned_to => group,
                      :is_private => true)
                    Role.find(2).update! :issues_visibility => 'default'
                    issues = Issue.visible(User.find(8)).to_a
                    assert issues.any?
                    assert issues.include?(issue)
                    Role.find(2).update! :issues_visibility => 'own'
                    issues = Issue.visible(User.find(8)).to_a
                    assert issues.any?
                    assert_include issue, issues
                  end
                end
                def test_visible_scope_for_member_with_limited_tracker_ids
                  role = Role.find(1)
                  role.set_permission_trackers :view_issues, [2]
                  role.save!
                  user = User.find(2)
                  issues = Issue.where(:project_id => 1).visible(user).to_a
                  assert issues.any?
                  assert_equal [2], issues.map(&:tracker_id).uniq
                  assert Issue.where(:project_id => 1).all? {|issue| issue.visible?(user) ^ issue.tracker_id != 2}
                end
                def test_visible_scope_should_consider_tracker_ids_on_each_project
                  user = User.generate!
                  project1 = Project.generate!
                  role1 = Role.generate!
                  role1.add_permission! :view_issues
                  role1.set_permission_trackers :view_issues, :all
                  role1.save!
                  User.add_to_project(user, project1, role1)
                  project2 = Project.generate!
                  role2 = Role.generate!
                  role2.add_permission! :view_issues
                  role2.set_permission_trackers :view_issues, [2]
                  role2.save!
                  User.add_to_project(user, project2, role2)
                  visible_issues = [
                    Issue.generate!(:project => project1, :tracker_id => 1),
                    Issue.generate!(:project => project1, :tracker_id => 2),
                    Issue.generate!(:project => project2, :tracker_id => 2)
                  ]
                  hidden_issue = Issue.generate!(:project => project2, :tracker_id => 1)
                  issues = Issue.where(:project_id => [project1.id, project2.id]).visible(user)
                  assert_equal visible_issues.map(&:id), issues.ids.sort
                  assert visible_issues.all? {|issue| issue.visible?(user)}
                  assert !hidden_issue.visible?(user)
                end
                def test_visible_scope_should_not_consider_roles_without_view_issues_permission
                  user = User.generate!
                  role1 = Role.generate!
                  role1.remove_permission! :view_issues
                  role1.set_permission_trackers :view_issues, :all
                  role1.save!
                  role2 = Role.generate!
                  role2.add_permission! :view_issues
                  role2.set_permission_trackers :view_issues, [2]
                  role2.save!
                  User.add_to_project(user, Project.find(1), [role1, role2])
                  issues = Issue.where(:project_id => 1).visible(user).to_a
                  assert issues.any?
                  assert_equal [2], issues.map(&:tracker_id).uniq
                  assert Issue.where(:project_id => 1).all? {|issue| issue.visible?(user) ^ issue.tracker_id != 2}
                end
                def test_visible_scope_for_admin
                  user = User.find(1)
                  user.members.each(&:destroy)
                  assert user.projects.empty?
                  issues = Issue.visible(user).to_a
                  assert issues.any?
                  # Admin should see issues on private projects that admin 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).to_a
                  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).to_a
                  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
                  user = User.generate!
                  Member.create!(:project_id => 1, :principal => user, :role_ids => [1])
                  parent = Issue.generate!(:assigned_to => user)
                  assert parent.visible?(user)
                  child1 = Issue.generate!(:parent_issue_id => parent.id, :assigned_to => user)
                  child2 = Issue.generate!(:parent_issue_id => parent.id, :assigned_to => user)
                  parent.reload
                  child1.reload
                  child2.reload
                  assert child1.visible?(user)
                  assert child2.visible?(user)
                  assert_equal 2, parent.descendants.count
                  assert_equal 2, parent.descendants.visible(user).count
                  # awesome_nested_set 2-1-stable branch has regression.
                  # https://github.com/collectiveidea/awesome_nested_set/commit/3d5ac746542b564f6586c2316180254b088bebb6
                  # ActiveRecord::StatementInvalid: SQLite3::SQLException: ambiguous column name: lft:
                  assert_equal 2, parent.descendants.collect{|i| i}.size
                  assert_equal 2, parent.descendants.visible(user).collect{|i| i}.size
                end
                def test_visible_scope_with_unsaved_user_should_not_raise_an_error
                  user = User.new
                  assert_nothing_raised do
                    Issue.visible(user).to_a
                  end
                end
                def test_open_scope
                  issues = Issue.open.to_a
                  assert_nil issues.detect(&:closed?)
                end
                def test_open_scope_with_arg
                  issues = Issue.open(false).to_a
                  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_assigned_to_scope_should_return_issues_assigned_to_the_user
                  user = User.generate!
                  issue = Issue.generate!
                  Issue.where(:id => issue.id).update_all :assigned_to_id => user.id
                  assert_equal [issue], Issue.assigned_to(user).to_a
                end
                def test_assigned_to_scope_should_return_issues_assigned_to_the_user_groups
                  group = Group.generate!
                  user = User.generate!
                  group.users << user
                  issue = Issue.generate!
                  Issue.where(:id => issue.id).update_all :assigned_to_id => group.id
                  assert_equal [issue], Issue.assigned_to(user).to_a
                end
                def test_issue_should_be_readonly_on_closed_project
                  issue = Issue.find(1)
                  user = User.find(1)
                  assert_equal true, issue.visible?(user)
                  assert_equal true, issue.editable?(user)
                  assert_equal true, issue.deletable?(user)
                  issue.project.close
                  issue.reload
                  assert_equal true, issue.visible?(user)
                  assert_equal false, issue.editable?(user)
                  assert_equal false, issue.deletable?(user)
                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!(: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 "Cannot 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_setting_project_should_set_version_to_default_version
                  version = Version.generate!(:project_id => 1)
                  Project.find(1).update!(:default_version_id => version.id)
                  issue = Issue.new(:project_id => 1)
                  assert_equal version, issue.fixed_version
                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_changing_tracker_should_clear_disabled_core_fields
                  tracker = Tracker.find(2)
                  tracker.core_fields = tracker.core_fields - %w(due_date)
                  tracker.save!
                  issue = Issue.generate!(:tracker_id => 1, :start_date => Date.today, :due_date => Date.today)
                  issue.save!
                  issue.tracker_id = 2
                  issue.save!
                  assert_not_nil issue.start_date
                  assert_nil issue.due_date
                end
                def test_attribute_cleared_on_tracker_change_should_be_journalized
                  CustomField.delete_all
                  tracker = Tracker.find(2)
                  tracker.core_fields = tracker.core_fields - %w(due_date)
                  tracker.save!
                  issue = Issue.generate!(:tracker_id => 1, :due_date => Date.today)
                  issue.save!
                  assert_difference 'Journal.count' do
                    issue.init_journal User.find(1)
                    issue.tracker_id = 2
                    issue.save!
                    assert_nil issue.due_date
                  end
                  journal = Journal.order('id DESC').first
                  details = journal.details.select {|d| d.prop_key == 'due_date'}
                  assert_equal 1, details.count
                end
                def test_reload_should_reload_custom_field_values
                  issue = Issue.generate!
                  issue.custom_field_values = {'2' => 'Foo'}
                  issue.save!
                  issue = Issue.order('id desc').first
                  assert_equal 'Foo', issue.custom_field_value(2)
                  issue.custom_field_values = {'2' => 'Bar'}
                  assert_equal 'Bar', issue.custom_field_value(2)
                  issue.reload
                  assert_equal 'Foo', issue.custom_field_value(2)
                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_equal [], 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_consider_group_assignment
                  WorkflowTransition.delete_all
                  WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                                             :old_status_id => 1, :new_status_id => 4,
                                             :author => false, :assignee => true)
                  group = Group.generate!
                  Member.create!(:project_id => 1, :principal => group, :role_ids => [1])
                  user = User.find(2)
                  group.users << user
                  with_settings :issue_group_assignment => '1' do
                    issue = Issue.generate!(:author_id => 1, :assigned_to => group)
                    assert_include 4, issue.new_statuses_allowed_to(user).map(&:id)
                  end
                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.where(: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_allowed_statuses_and_current_status_when_copying
                  Tracker.find(1).generate_transitions! :role_id => 1, :clear => true, 0 => [1, 3]
                  orig = Issue.generate!(:project_id => 1, :tracker_id => 1, :status_id => 4)
                  issue = orig.copy
                  assert_equal [1, 3, 4], issue.new_statuses_allowed_to(User.find(2)).map(&:id)
                  assert_equal 4, issue.status_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!
                  user = User.find(2)
                  issue = Issue.new(:project => Project.find(1), :tracker => source)
                  issue.send :safe_attributes=, {'tracker_id' => 2, 'due_date' => '2012-07-14'}, user
                  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_editable_custom_fields_should_return_custom_field_that_is_enabled_for_the_role_only
                  enabled_cf = IssueCustomField.generate!(:is_for_all => true, :tracker_ids => [1], :visible => false, :role_ids => [1,2])
                  disabled_cf = IssueCustomField.generate!(:is_for_all => true, :tracker_ids => [1], :visible => false, :role_ids => [2])
                  user = User.find(2)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1)
                  assert_include enabled_cf, issue.editable_custom_fields(user)
                  assert_not_include disabled_cf, issue.editable_custom_fields(user)
                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 cannot be blank", "Due date cannot be blank", "Foo cannot 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 cannot be blank", "Start date cannot 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_that_is_disabled_for_the_tracker_should_not_be_required
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role_id => 1, :field_name => 'start_date',
                                             :rule => 'required')
                  user = User.find(2)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1,
                                    :subject => 'Required fields', :author => user)
                  assert !issue.save
                  assert_include "Start date cannot be blank", issue.errors.full_messages
                  tracker = Tracker.find(1)
                  tracker.core_fields -= %w(start_date)
                  tracker.save!
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1,
                                    :subject => 'Required fields', :author => user)
                  assert issue.save
                end
                def test_category_should_not_be_required_if_project_has_no_categories
                  Project.find(1).issue_categories.delete_all
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                    :role_id => 1, :field_name => 'category_id',:rule => 'required')
                  user = User.find(2)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1,
                                    :subject => 'Required fields', :author => user)
                  assert_save issue
                end
                def test_fixed_version_should_not_be_required_no_assignable_versions
                  Version.delete_all
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                    :role_id => 1, :field_name => 'fixed_version_id',:rule => 'required')
                  user = User.find(2)
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1,
                                    :subject => 'Required fields', :author => user)
                  assert_save issue
                end
                def test_required_custom_field_that_is_not_visible_for_the_user_should_not_be_required
                  CustomField.delete_all
                  field = IssueCustomField.generate!(:is_required => true, :visible => false, :role_ids => [1], :trackers => Tracker.all, :is_for_all => true)
                  user = User.generate!
                  User.add_to_project(user, Project.find(1), Role.find(2))
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1,
                                    :subject => 'Required fields', :author => user)
                  assert_save issue
                end
                def test_required_custom_field_that_is_visible_for_the_user_should_be_required
                  CustomField.delete_all
                  field = IssueCustomField.generate!(:is_required => true, :visible => false, :role_ids => [1], :trackers => Tracker.all, :is_for_all => true)
                  user = User.generate!
                  User.add_to_project(user, Project.find(1), Role.find(1))
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1,
                                    :subject => 'Required fields', :author => user)
                  assert !issue.save
                  assert_include "#{field.name} cannot be blank", issue.errors.full_messages
                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 => 3, :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
                # A field that is not visible by role 2 and readonly by role 1 should be readonly for user with role 1 and 2
                def test_read_only_attribute_names_should_include_custom_fields_that_combine_readonly_and_not_visible_for_roles
                  field = IssueCustomField.generate!(
                    :is_for_all => true, :trackers => Tracker.all, :visible => false, :role_ids => [1]
                  )
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(
                    :old_status_id => 1, :tracker_id => 1, :role_id => 1, :field_name => field.id, :rule => 'readonly'
                  )
                  user = User.generate!
                  project = Project.find(1)
                  User.add_to_project(user, project, Role.where(:id => [1, 2]))
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                  assert_equal [field.id.to_s], issue.read_only_attribute_names(user)
                end
                def test_workflow_rules_should_ignore_roles_without_issue_permissions
                  role = Role.generate! :permissions => [:view_issues, :edit_issues]
                  ignored_role = Role.generate! :permissions => [:view_issues]
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role => role, :field_name => 'due_date',
                                             :rule => 'required')
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role => role, :field_name => 'start_date',
                                             :rule => 'readonly')
                  WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                             :role => role, :field_name => 'done_ratio',
                                             :rule => 'readonly')
                  user = User.generate!
                  User.add_to_project user, Project.find(1), [role, ignored_role]
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                  assert_equal %w(due_date), issue.required_attribute_names(user)
                  assert_equal %w(done_ratio start_date), issue.read_only_attribute_names(user).sort
                end
                def test_workflow_rules_should_work_for_member_with_duplicate_role
                  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 => 'readonly')
                  user = User.generate!
                  m = Member.new(:user_id => user.id, :project_id => 1)
                  m.member_roles.build(:role_id => 1)
                  m.member_roles.build(:role_id => 1)
                  m.save!
                  issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                  assert_equal %w(due_date), issue.required_attribute_names(user)
                  assert_equal %w(start_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_to_another_project_should_clear_assignee_if_not_valid
                  issue = Issue.generate!(:project_id => 1, :assigned_to_id => 2)
                  project = Project.generate!
                  issue = Issue.new.copy_from(1)
                  issue.project = project
                  assert_nil issue.assigned_to
                end
                def test_copy_should_copy_status
                  orig = Issue.find(8)
                  assert orig.status != orig.default_status
                  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_as_a_child_of_copied_issue_should_not_copy_itself
                  parent = Issue.generate!
                  child1 = Issue.generate!(:parent_issue_id => parent.id, :subject => 'Child 1')
                  child2 = Issue.generate!(:parent_issue_id => parent.id, :subject => 'Child 2')
                  copy = parent.reload.copy
                  copy.parent_issue_id = parent.id
                  copy.author = User.find(7)
                  assert_difference 'Issue.count', 3 do
                    assert copy.save
                  end
                  parent.reload
                  copy.reload
                  assert_equal parent, copy.parent
                  assert_equal 3, parent.children.count
                  assert_equal 5, parent.descendants.count
                  assert_equal 2, copy.children.count
                  assert_equal 2, copy.descendants.count
                end
                def test_copy_as_a_descendant_of_copied_issue_should_not_copy_itself
                  parent = Issue.generate!
                  child1 = Issue.generate!(:parent_issue_id => parent.id, :subject => 'Child 1')
                  child2 = Issue.generate!(:parent_issue_id => parent.id, :subject => 'Child 2')
                  copy = parent.reload.copy
                  copy.parent_issue_id = child1.id
                  copy.author = User.find(7)
                  assert_difference 'Issue.count', 3 do
                    assert copy.save
                  end
                  parent.reload
                  child1.reload
                  copy.reload
                  assert_equal child1, copy.parent
                  assert_equal 2, parent.children.count
                  assert_equal 5, parent.descendants.count
                  assert_equal 1, child1.children.count
                  assert_equal 3, child1.descendants.count
                  assert_equal 2, copy.children.count
                  assert_equal 2, copy.descendants.count
                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_copy_should_clear_closed_on
                  copied_open = Issue.find(8).copy(:status_id => 1)
                  assert copied_open.save
                  assert_nil copied_open.closed_on
                  copied_closed = Issue.find(8).copy
                  assert copied_closed.save
                  assert_not_nil copied_closed.closed_on
                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_close_duplicates_with_private_notes
                  issue = Issue.generate!
                  duplicate = Issue.generate!
                  IssueRelation.create!(:issue_from => duplicate, :issue_to => issue,
                                        :relation_type => IssueRelation::TYPE_DUPLICATES)
                  assert issue.reload.duplicates.include?(duplicate)
                  # Closing issue with private notes
                  issue.init_journal(User.first, "Private notes")
                  issue.private_notes = true
                  issue.status = IssueStatus.where(:is_closed => true).first
                  assert_save issue
                  duplicate.reload
                  assert journal = duplicate.journals.detect {|journal| journal.notes == "Private notes"}
                  assert_equal true, journal.private_notes
                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_equal [], 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_equal [], 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_equal [], 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! :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_should_include_projects_with_issue_tracking_enabled
                  assert_include Project.find(2), Issue.allowed_target_projects(User.find(2))
                end
                def test_allowed_target_projects_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(User.find(2))
                end
                def test_allowed_target_projects_should_not_include_projects_without_trackers
                  project = Project.generate!(:tracker_ids => [])
                  assert project.trackers.empty?
                  assert_not_include project, Issue.allowed_target_projects(User.find(1))
                end
                def test_allowed_target_trackers_with_one_role_allowed_on_all_trackers
                  user = User.generate!
                  role = Role.generate!
                  role.add_permission! :add_issues
                  role.set_permission_trackers :add_issues, :all
                  role.save!
                  User.add_to_project(user, Project.find(1), role)
                  assert_equal [1, 2, 3], Issue.new(:project => Project.find(1)).allowed_target_trackers(user).ids.sort
                end
                def test_allowed_target_trackers_with_one_role_allowed_on_some_trackers
                  user = User.generate!
                  role = Role.generate!
                  role.add_permission! :add_issues
                  role.set_permission_trackers :add_issues, [1, 3]
                  role.save!
                  User.add_to_project(user, Project.find(1), role)
                  assert_equal [1, 3], Issue.new(:project => Project.find(1)).allowed_target_trackers(user).ids.sort
                end
                def test_allowed_target_trackers_with_two_roles_allowed_on_some_trackers
                  user = User.generate!
                  role1 = Role.generate!
                  role1.add_permission! :add_issues
                  role1.set_permission_trackers :add_issues, [1]
                  role1.save!
                  role2 = Role.generate!
                  role2.add_permission! :add_issues
                  role2.set_permission_trackers :add_issues, [3]
                  role2.save!
                  User.add_to_project(user, Project.find(1), [role1, role2])
                  assert_equal [1, 3], Issue.new(:project => Project.find(1)).allowed_target_trackers(user).ids.sort
                end
                def test_allowed_target_trackers_with_two_roles_allowed_on_all_trackers_and_some_trackers
                  user = User.generate!
                  role1 = Role.generate!
                  role1.add_permission! :add_issues
                  role1.set_permission_trackers :add_issues, :all
                  role1.save!
                  role2 = Role.generate!
                  role2.add_permission! :add_issues
                  role2.set_permission_trackers :add_issues, [1, 3]
                  role2.save!
                  User.add_to_project(user, Project.find(1), [role1, role2])
                  assert_equal [1, 2, 3], Issue.new(:project => Project.find(1)).allowed_target_trackers(user).ids.sort
                end
                def test_allowed_target_trackers_should_not_consider_roles_without_add_issues_permission
                  user = User.generate!
                  role1 = Role.generate!
                  role1.remove_permission! :add_issues
                  role1.set_permission_trackers :add_issues, :all
                  role1.save!
                  role2 = Role.generate!
                  role2.add_permission! :add_issues
                  role2.set_permission_trackers :add_issues, [1, 3]
                  role2.save!
                  User.add_to_project(user, Project.find(1), [role1, role2])
                  assert_equal [1, 3], Issue.new(:project => Project.find(1)).allowed_target_trackers(user).ids.sort
                end
                def test_allowed_target_trackers_without_project_should_be_empty
                  issue = Issue.new
                  assert_nil issue.project
                  assert_equal [], issue.allowed_target_trackers(User.find(2)).ids
                end
                def test_allowed_target_trackers_should_include_current_tracker
                  user = User.generate!
                  role = Role.generate!
                  role.add_permission! :add_issues
                  role.set_permission_trackers :add_issues, [3]
                  role.save!
                  User.add_to_project(user, Project.find(1), role)
                  issue = Issue.generate!(:project => Project.find(1), :tracker => Tracker.find(1))
                  assert_equal [1, 3], issue.allowed_target_trackers(user).ids.sort
                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!(:fixed_version_id => 3)
                  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
+                 assert_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!(: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!(:fixed_version_id => 3)
                  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
+                 assert_nil issue.fixed_version
                end
                def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide
                  issue = Issue.find(1)
                  issue.update!(: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! :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! :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
                test "#copy should not create a journal" do
                  copy = Issue.find(1).copy({:project_id => 3, :tracker_id => 2}, :link => false)
                  copy.save!
                  assert_equal 0, copy.reload.journals.size
                end
                test "#copy should allow assigned_to changes" do
                  user = User.generate!
                  Member.create!(:project_id => 3, :principal => user, :role_ids => [1])
                  copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => user.id)
                  assert_equal user.id, copy.assigned_to_id
                end
                test "#copy should allow status changes" do
                  copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2, :status_id => 2)
                  assert_equal 2, copy.status_id
                end
                test "#copy should allow start date changes" do
                  date = Date.today
                  copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2, :start_date => date)
                  assert_equal date, copy.start_date
                end
                test "#copy should allow due date changes" do
                  date = Date.today
                  copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2, :due_date => date)
                  assert_equal date, copy.due_date
                end
                test "#copy should set current user as author" do
                  User.current = User.find(9)
                  copy = Issue.find(1).copy(:project_id => 3, :tracker_id => 2)
                  assert_equal User.current, copy.author
                end
                test "#copy should create a journal with notes" do
                  date = Date.today
                  notes = "Notes added when copying"
                  copy = Issue.find(1).copy({:project_id => 3, :tracker_id => 2, :start_date => date}, :link => false)
                  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
                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! :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_destroy_should_delete_time_entries_custom_values
                  issue = Issue.generate!
                  time_entry = TimeEntry.generate!(:issue => issue, :custom_field_values => {10 => '1'})
                  assert_difference 'CustomValue.where(:customized_type => "TimeEntry").count', -1 do
                    assert issue.destroy
                  end
                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! :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.reload
                  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.reload
                  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.reload
                  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_child_issue_should_consider_parent_soonest_start_on_create
                  set_language_if_valid 'en'
                  issue1 = Issue.generate!(:start_date => '2012-10-15', :due_date => '2012-10-17')
                  issue2 = Issue.generate!(:start_date => '2012-10-18', :due_date => '2012-10-20')
                  IssueRelation.create!(:issue_from => issue1, :issue_to => issue2,
                                        :relation_type => IssueRelation::TYPE_PRECEDES)
                  issue1.reload
                  issue2.reload
                  assert_equal Date.parse('2012-10-18'), issue2.start_date
                  with_settings :date_format => '%m/%d/%Y' do
                    child = Issue.new(:parent_issue_id => issue2.id, :start_date => '2012-10-16',
                      :project_id => 1, :tracker_id => 1, :status_id => 1, :subject => 'Child', :author_id => 1)
                    assert !child.valid?
                    assert_include 'Start date cannot be earlier than 10/18/2012 because of preceding issues', child.errors.full_messages
                    assert_equal Date.parse('2012-10-18'), child.soonest_start
                    child.start_date = '2012-10-18'
                    assert child.save
                  end
                end
                def test_setting_parent_to_a_an_issue_that_precedes_should_not_validate
                  # tests that 3 cannot have 1 as parent:
                  #
                  # 1 -> 2 -> 3
                  #
                  set_language_if_valid 'en'
                  issue1 = Issue.generate!
                  issue2 = Issue.generate!
                  issue3 = Issue.generate!
                  IssueRelation.create!(:issue_from => issue1, :issue_to => issue2, :relation_type => IssueRelation::TYPE_PRECEDES)
                  IssueRelation.create!(:issue_from => issue2, :issue_to => issue3, :relation_type => IssueRelation::TYPE_PRECEDES)
                  issue3.reload
                  issue3.parent_issue_id = issue1.id
                  assert !issue3.valid?
                  assert_include 'Parent task is invalid', issue3.errors.full_messages
                end
                def test_setting_parent_to_a_an_issue_that_follows_should_not_validate
                  # tests that 1 cannot have 3 as parent:
                  #
                  # 1 -> 2 -> 3
                  #
                  set_language_if_valid 'en'
                  issue1 = Issue.generate!
                  issue2 = Issue.generate!
                  issue3 = Issue.generate!
                  IssueRelation.create!(:issue_from => issue1, :issue_to => issue2, :relation_type => IssueRelation::TYPE_PRECEDES)
                  IssueRelation.create!(:issue_from => issue2, :issue_to => issue3, :relation_type => IssueRelation::TYPE_PRECEDES)
                  issue1.reload
                  issue1.parent_issue_id = issue3.id
                  assert !issue1.valid?
                  assert_include 'Parent task is invalid', issue1.errors.full_messages
                end
                def test_setting_parent_to_a_an_issue_that_precedes_through_hierarchy_should_not_validate
                  # tests that 4 cannot have 1 as parent:
                  # changing the due date of 4 would update the end date of 1 which would reschedule 2
                  # which would change the end date of 3 which would reschedule 4 and so on...
                  #
                  #      3 -> 4
                  #      ^
                  # 1 -> 2
                  #
                  set_language_if_valid 'en'
                  issue1 = Issue.generate!
                  issue2 = Issue.generate!
                  IssueRelation.create!(:issue_from => issue1, :issue_to => issue2, :relation_type => IssueRelation::TYPE_PRECEDES)
                  issue3 = Issue.generate!
                  issue2.reload
                  issue2.parent_issue_id = issue3.id
                  issue2.save!
                  issue4 = Issue.generate!
                  IssueRelation.create!(:issue_from => issue3, :issue_to => issue4, :relation_type => IssueRelation::TYPE_PRECEDES)
                  issue4.reload
                  issue4.parent_issue_id = issue1.id
                  assert !issue4.valid?
                  assert_include 'Parent task is invalid', issue4.errors.full_messages
                end
                def test_issue_and_following_issue_should_be_able_to_be_moved_to_the_same_parent
                  set_language_if_valid 'en'
                  issue1 = Issue.generate!
                  issue2 = Issue.generate!
                  relation = IssueRelation.create!(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_FOLLOWS)
                  parent = Issue.generate!
                  issue1.reload.parent_issue_id = parent.id
                  assert_save issue1
                  parent.reload
                  issue2.reload.parent_issue_id = parent.id
                  assert_save issue2
                  assert IssueRelation.exists?(relation.id)
                end
                def test_issue_and_preceding_issue_should_be_able_to_be_moved_to_the_same_parent
                  set_language_if_valid 'en'
                  issue1 = Issue.generate!
                  issue2 = Issue.generate!
                  relation = IssueRelation.create!(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_PRECEDES)
                  parent = Issue.generate!
                  issue1.reload.parent_issue_id = parent.id
                  assert_save issue1
                  parent.reload
                  issue2.reload.parent_issue_id = parent.id
                  assert_save issue2
                  assert IssueRelation.exists?(relation.id)
                end
                def test_issue_and_blocked_issue_should_be_able_to_be_moved_to_the_same_parent
                  set_language_if_valid 'en'
                  issue1 = Issue.generate!
                  issue2 = Issue.generate!
                  relation = IssueRelation.create!(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_BLOCKED)
                  parent = Issue.generate!
                  issue1.reload.parent_issue_id = parent.id
                  assert_save issue1
                  parent.reload
                  issue2.reload.parent_issue_id = parent.id
                  assert_save issue2
                  assert IssueRelation.exists?(relation.id)
                end
                def test_issue_and_blocking_issue_should_be_able_to_be_moved_to_the_same_parent
                  set_language_if_valid 'en'
                  issue1 = Issue.generate!
                  issue2 = Issue.generate!
                  relation = IssueRelation.create!(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_BLOCKS)
                  parent = Issue.generate!
                  issue1.reload.parent_issue_id = parent.id
                  assert_save issue1
                  parent.reload
                  issue2.reload.parent_issue_id = parent.id
                  assert_save issue2
                  assert IssueRelation.exists?(relation.id)
                end
                def test_issue_copy_should_be_able_to_be_moved_to_the_same_parent_as_copied_issue
                  issue = Issue.generate!
                  parent = Issue.generate!
                  issue.parent_issue_id = parent.id
                  issue.save!
                  issue.reload
                  copy = Issue.new.copy_from(issue, :link => true)
                  relation = new_record(IssueRelation) do
                    copy.save!
                  end
                  copy.parent_issue_id = parent.id
                  assert_save copy
                  assert IssueRelation.exists?(relation.id)
                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
                test "#behind_schedule? should be false if the issue has no start_date" do
                  assert !Issue.new(:start_date => nil,
                                    :due_date => 1.day.from_now.to_date,
                                    :done_ratio => 0).behind_schedule?
                end
                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
                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
                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
                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
                test "#assignable_users should be Users" do
                  assert_kind_of User, Issue.find(1).assignable_users.first
                end
                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
                def test_assignable_users_should_not_include_anonymous_user
                  issue = Issue.generate!(:author => User.anonymous)
                  assert !issue.assignable_users.include?(User.anonymous)
                end
                def test_assignable_users_should_not_include_locked_user
                  user = User.generate!
                  issue = Issue.generate!(:author => user)
                  user.lock!
                  assert !issue.assignable_users.include?(user)
                end
                def test_assignable_users_should_include_the_current_assignee
                  user = User.generate!
                  Member.create!(:project_id => 1, :principal => user, :role_ids => [1])
                  issue = Issue.generate!(:assigned_to => user)
                  user.lock!
                  assert Issue.find(issue.id).assignable_users.include?(user)
                end
                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
                test "#assignable_users with issue_group_assignment should include groups" do
                  issue = Issue.new(:project => Project.find(2))
                  with_settings :issue_group_assignment => '1' do
                    assert_equal %w(Group User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
                    assert issue.assignable_users.include?(Group.find(11))
                  end
                end
                test "#assignable_users without issue_group_assignment should not include groups" do
                  issue = Issue.new(:project => Project.find(2))
                  with_settings :issue_group_assignment => '0' do
                    assert_equal %w(User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
                    assert !issue.assignable_users.include?(Group.find(11))
                  end
                end
                def test_assignable_users_should_not_include_builtin_groups
                  Member.create!(:project_id => 1, :principal => Group.non_member, :role_ids => [1])
                  Member.create!(:project_id => 1, :principal => Group.anonymous, :role_ids => [1])
                  issue = Issue.new(:project => Project.find(1))
                  with_settings :issue_group_assignment => '1' do
                    assert_nil issue.assignable_users.detect {|u| u.is_a?(GroupBuiltin)}
                  end
                end
                def test_assignable_users_should_not_include_users_that_cannot_view_the_tracker
                  user = User.find(3)
                  role = Role.find(2)
                  role.set_permission_trackers :view_issues, [1, 3]
                  role.save!
                  issue1 = Issue.new(:project_id => 1, :tracker_id => 1)
                  issue2 = Issue.new(:project_id => 1, :tracker_id => 2)
                  assert_include user, issue1.assignable_users
                  assert_not_include user, issue2.assignable_users
                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')
                  with_settings :notified_events => %w(issue_added) do
                    assert issue.save
                    assert_equal 1, ActionMailer::Base.deliveries.size
                  end
                end
                def test_create_should_send_one_email_notification_with_both_settings
                  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')
                  with_settings :notified_events => %w(issue_added issue_updated) do
                    assert issue.save
                    assert_equal 1, ActionMailer::Base.deliveries.size
                  end
                end
                def test_create_should_not_send_email_notification_with_no_setting
                  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')
                  with_settings :notified_events => [] do
                    assert issue.save
                    assert_equal 0, ActionMailer::Base.deliveries.size
                  end
                end
                def test_update_should_notify_previous_assignee
                  ActionMailer::Base.deliveries.clear
                  user = User.find(3)
                  user.members.update_all ["mail_notification = ?", false]
                  user.update! :mail_notification => 'only_assigned'
                  with_settings :notified_events => %w(issue_updated) do
                    issue = Issue.find(2)
                    issue.init_journal User.find(1)
                    issue.assigned_to = nil
                    issue.save!
                    assert_include user.mail, ActionMailer::Base.deliveries.last.bcc
                  end
                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'
                  with_settings :notified_events => %w(issue_updated) do
                    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
                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.order('id DESC').first
                  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.where(:id => 1).update_all("description = NULL")
                  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_custom_value_cleared_on_tracker_change_should_be_journalized
                  a = IssueCustomField.generate!(:tracker_ids => [1])
                  issue = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {a.id.to_s => "foo"})
                  assert_equal "foo", issue.custom_field_value(a)
                  journal = new_record(Journal) do
                    issue.init_journal(User.first)
                    issue.tracker_id = 2
                    issue.save!
                  end
                  details = journal.details.select {|d| d.property == 'cf' && d.prop_key == a.id.to_s}
                  assert_equal 1, details.size
                  assert_equal 'foo', details.first.old_value
                  assert_nil details.first.value
                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
                test "#done_ratio should use the issue_status according to Setting.issue_done_ratio" do
                  @issue = Issue.find(1)
                  @issue_status = IssueStatus.find(1)
                  @issue_status.update!(:default_done_ratio => 50)
                  @issue2 = Issue.find(2)
                  @issue_status2 = IssueStatus.find(2)
                  @issue_status2.update!(:default_done_ratio => 0)
                  with_settings :issue_done_ratio => 'issue_field' do
                    assert_equal 0, @issue.done_ratio
                    assert_equal 30, @issue2.done_ratio
                  end
                  with_settings :issue_done_ratio => 'issue_status' do
                    assert_equal 50, @issue.done_ratio
                    assert_equal 0, @issue2.done_ratio
                  end
                end
                test "#update_done_ratio_from_issue_status should update done_ratio according to Setting.issue_done_ratio" do
                  @issue = Issue.find(1)
                  @issue_status = IssueStatus.find(1)
                  @issue_status.update!(:default_done_ratio => 50)
                  @issue2 = Issue.find(2)
                  @issue_status2 = IssueStatus.find(2)
                  @issue_status2.update!(:default_done_ratio => 0)
                  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
                  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
                test "#by_tracker" do
                  User.current = User.anonymous
                  groups = Issue.by_tracker(Project.find(1))
                  assert_equal 3, groups.count
                  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.count
                  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.count
                  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.count
                  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.count
                  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.count
                  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.count
                  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
                test "Issue#recipients should include project recipients" do
                  issue = Issue.generate!
                  assert issue.project.recipients.present?
                  issue.project.recipients.each do |project_recipient|
                    assert issue.recipients.include?(project_recipient)
                  end
                end
                test "Issue#recipients should include the author if the author is active" do
                  issue = Issue.generate!(:author => User.generate!)
                  assert issue.author, "No author set for Issue"
                  assert issue.recipients.include?(issue.author.mail)
                end
                test "Issue#recipients should include the assigned to user if the assigned to user is active" do
                  user = User.generate!
                  Member.create!(:project_id => 1, :principal => user, :role_ids => [1])
                  issue = Issue.generate!(:assigned_to => user)
                  assert issue.assigned_to, "No assigned_to set for Issue"
                  assert issue.recipients.include?(issue.assigned_to.mail)
                end
                test "Issue#recipients should not include users who opt out of all email" do
                  issue = Issue.generate!(:author => User.generate!)
                  issue.author.update!(:mail_notification => :none)
                  assert !issue.recipients.include?(issue.author.mail)
                end
                test "Issue#recipients should not include the issue author if they are only notified of assigned issues" do
                  issue = Issue.generate!(:author => User.generate!)
                  issue.author.update!(:mail_notification => :only_assigned)
                  assert !issue.recipients.include?(issue.author.mail)
                end
                test "Issue#recipients should not include the assigned user if they are only notified of owned issues" do
                  user = User.generate!
                  Member.create!(:project_id => 1, :principal => user, :role_ids => [1])
                  issue = Issue.generate!(:assigned_to => user)
                  issue.assigned_to.update!(:mail_notification => :only_owner)
                  assert !issue.recipients.include?(issue.assigned_to.mail)
                end
                def test_last_journal_id_with_journals_should_return_the_journal_id
                  assert_equal 2, Issue.find(1).last_journal_id
                end
                def test_last_journal_id_without_journals_should_return_nil
                  assert_nil Issue.find(3).last_journal_id
                end
                def test_journals_after_should_return_journals_with_greater_id
                  assert_equal [Journal.find(2)], Issue.find(1).journals_after('1')
                  assert_equal [], Issue.find(1).journals_after('2')
                end
                def test_journals_after_with_blank_arg_should_return_all_journals
                  assert_equal [Journal.find(1), Journal.find(2)], Issue.find(1).journals_after('')
                end
                def test_css_classes_should_include_tracker
                  issue = Issue.new(:tracker => Tracker.find(2))
                  classes = issue.css_classes.split(' ')
                  assert_include 'tracker-2', classes
                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_css_classes_should_include_user_and_group_assignment
                  project = Project.first
                  user = User.generate!
                  group = Group.generate!
                  Member.create!(:principal => group, :project => project, :role_ids => [1, 2])
                  group.users << user
                  assert user.member_of?(project)
                  issue1 = Issue.generate(:assigned_to_id => group.id)
                  assert_include 'assigned-to-my-group', issue1.css_classes(user)
                  assert_not_include 'assigned-to-me', issue1.css_classes(user)
                  issue2 = Issue.generate(:assigned_to_id => user.id)
                  assert_not_include 'assigned-to-my-group', issue2.css_classes(user)
                  assert_include 'assigned-to-me', issue2.css_classes(user)
                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
                def test_save_attachments_with_array_should_warn_about_missing_tokens
                  set_tmp_attachments_directory
                  issue = Issue.generate!
                  issue.save_attachments([
                    {'token' => 'missing'}
                  ])
                  assert !issue.save
                  assert issue.errors[:base].present?
                  assert_equal 0, issue.reload.attachments.count
                end
                def test_closed_on_should_be_nil_when_creating_an_open_issue
                  issue = Issue.generate!(:status_id => 1).reload
                  assert !issue.closed?
                  assert_nil issue.closed_on
                end
                def test_closed_on_should_be_set_when_creating_a_closed_issue
                  issue = Issue.generate!(:status_id => 5).reload
                  assert issue.closed?
                  assert_not_nil issue.closed_on
                  assert_equal issue.updated_on, issue.closed_on
                  assert_equal issue.created_on, issue.closed_on
                end
                def test_closed_on_should_be_nil_when_updating_an_open_issue
                  issue = Issue.find(1)
                  issue.subject = 'Not closed yet'
                  issue.save!
                  issue.reload
                  assert_nil issue.closed_on
                end
                def test_closed_on_should_be_set_when_closing_an_open_issue
                  issue = Issue.find(1)
                  issue.subject = 'Now closed'
                  issue.status_id = 5
                  issue.save!
                  issue.reload
                  assert_not_nil issue.closed_on
                  assert_equal issue.updated_on, issue.closed_on
                end
                def test_closed_on_should_not_be_updated_when_updating_a_closed_issue
                  issue = Issue.open(false).first
                  was_closed_on = issue.closed_on
                  assert_not_nil was_closed_on
                  issue.subject = 'Updating a closed issue'
                  issue.save!
                  issue.reload
                  assert_equal was_closed_on, issue.closed_on
                end
                def test_closed_on_should_be_preserved_when_reopening_a_closed_issue
                  issue = Issue.open(false).first
                  was_closed_on = issue.closed_on
                  assert_not_nil was_closed_on
                  issue.subject = 'Reopening a closed issue'
                  issue.status_id = 1
                  issue.save!
                  issue.reload
                  assert !issue.closed?
                  assert_equal was_closed_on, issue.closed_on
                end
                def test_status_was_should_return_nil_for_new_issue
                  issue = Issue.new
                  assert_nil issue.status_was
                end
                def test_status_was_should_return_status_before_change
                  issue = Issue.find(1)
                  issue.status = IssueStatus.find(2)
                  assert_equal IssueStatus.find(1), issue.status_was
                end
                def test_status_was_should_return_status_before_change_with_status_id
                  issue = Issue.find(1)
                  assert_equal IssueStatus.find(1), issue.status
                  issue.status_id = 2
                  assert_equal IssueStatus.find(1), issue.status_was
                end
                def test_status_was_should_be_reset_on_save
                  issue = Issue.find(1)
                  issue.status = IssueStatus.find(2)
                  assert_equal IssueStatus.find(1), issue.status_was
                  assert issue.save!
                  assert_equal IssueStatus.find(2), issue.status_was
                end
                def test_closing_should_return_true_when_closing_an_issue
                  issue = Issue.find(1)
                  issue.status = IssueStatus.find(2)
                  assert_equal false, issue.closing?
                  issue.status = IssueStatus.find(5)
                  assert_equal true, issue.closing?
                end
                def test_closing_should_return_true_when_closing_an_issue_with_status_id
                  issue = Issue.find(1)
                  issue.status_id = 2
                  assert_equal false, issue.closing?
                  issue.status_id = 5
                  assert_equal true, issue.closing?
                end
                def test_closing_should_return_true_for_new_closed_issue
                  issue = Issue.new
                  assert_equal false, issue.closing?
                  issue.status = IssueStatus.find(5)
                  assert_equal true, issue.closing?
                end
                def test_closing_should_return_true_for_new_closed_issue_with_status_id
                  issue = Issue.new
                  assert_equal false, issue.closing?
                  issue.status_id = 5
                  assert_equal true, issue.closing?
                end
                def test_closing_should_be_reset_after_save
                  issue = Issue.find(1)
                  issue.status_id = 5
                  assert_equal true, issue.closing?
                  issue.save!
                  assert_equal false, issue.closing?
                end
                def test_reopening_should_return_true_when_reopening_an_issue
                  issue = Issue.find(8)
                  issue.status = IssueStatus.find(6)
                  assert_equal false, issue.reopening?
                  issue.status = IssueStatus.find(2)
                  assert_equal true, issue.reopening?
                end
                def test_reopening_should_return_true_when_reopening_an_issue_with_status_id
                  issue = Issue.find(8)
                  issue.status_id = 6
                  assert_equal false, issue.reopening?
                  issue.status_id = 2
                  assert_equal true, issue.reopening?
                end
                def test_reopening_should_return_false_for_new_open_issue
                  issue = Issue.new
                  issue.status = IssueStatus.find(1)
                  assert_equal false, issue.reopening?
                end
                def test_reopening_should_be_reset_after_save
                  issue = Issue.find(8)
                  issue.status_id = 2
                  assert_equal true, issue.reopening?
                  issue.save!
                  assert_equal false, issue.reopening?
                end
                def test_default_status_without_tracker_should_be_nil
                  issue = Issue.new
                  assert_nil issue.tracker
                  assert_nil issue.default_status
                end
                def test_default_status_should_be_tracker_default_status
                  issue = Issue.new(:tracker_id => 1)
                  assert_not_nil issue.status
                  assert_equal issue.tracker.default_status, issue.default_status
                end
                def test_initializing_with_tracker_should_set_default_status
                  issue = Issue.new(:tracker => Tracker.find(1))
                  assert_not_nil issue.status
                  assert_equal issue.default_status, issue.status
                end
                def test_initializing_with_tracker_id_should_set_default_status
                  issue = Issue.new(:tracker_id => 1)
                  assert_not_nil issue.status
                  assert_equal issue.default_status, issue.status
                end
                def test_setting_tracker_should_set_default_status
                  issue = Issue.new
                  issue.tracker = Tracker.find(1)
                  assert_not_nil issue.status
                  assert_equal issue.default_status, issue.status
                end
                def test_changing_tracker_should_set_default_status_if_status_was_default
                  WorkflowTransition.delete_all
                  WorkflowTransition.create! :role_id => 1, :tracker_id => 2, :old_status_id => 2, :new_status_id => 1
                  Tracker.find(2).update! :default_status_id => 2
                  issue = Issue.new(:tracker_id => 1, :status_id => 1)
                  assert_equal IssueStatus.find(1), issue.status
                  issue.tracker = Tracker.find(2)
                  assert_equal IssueStatus.find(2), issue.status
                end
                def test_changing_tracker_should_set_default_status_if_status_is_not_used_by_tracker
                  WorkflowTransition.delete_all
                  Tracker.find(2).update! :default_status_id => 2
                  issue = Issue.new(:tracker_id => 1, :status_id => 3)
                  assert_equal IssueStatus.find(3), issue.status
                  issue.tracker = Tracker.find(2)
                  assert_equal IssueStatus.find(2), issue.status
                end
                def test_changing_tracker_should_keep_status_if_status_was_not_default_and_is_used_by_tracker
                  WorkflowTransition.delete_all
                  WorkflowTransition.create! :role_id => 1, :tracker_id => 2, :old_status_id => 2, :new_status_id => 3
                  Tracker.find(2).update! :default_status_id => 2
                  issue = Issue.new(:tracker_id => 1, :status_id => 3)
                  assert_equal IssueStatus.find(3), issue.status
                  issue.tracker = Tracker.find(2)
                  assert_equal IssueStatus.find(3), issue.status
                end
                def test_assigned_to_was_with_a_group
                  group = Group.find(10)
                  Member.create!(:project_id => 1, :principal => group, :role_ids => [1])
                  with_settings :issue_group_assignment => '1' do
                    issue = Issue.generate!(:assigned_to => group)
                    issue.reload.assigned_to = nil
                    assert_equal group, issue.assigned_to_was
                  end
                end
                def test_issue_overdue_should_respect_user_timezone
                  user_in_europe = users(:users_001)
                  user_in_europe.pref.update! :time_zone => 'UTC'
                  user_in_asia = users(:users_002)
                  user_in_asia.pref.update! :time_zone => 'Hongkong'
                  issue = Issue.generate! :due_date => Date.parse('2016-03-20')
                  # server time is UTC
                  time = Time.parse '2016-03-20 20:00 UTC'
                  Time.stubs(:now).returns(time)
                  Date.stubs(:today).returns(time.to_date)
                  # for a user in the same time zone as the server the issue is not overdue
                  # yet
                  User.current = user_in_europe
                  assert !issue.overdue?
                  # at the same time, a user in East Asia looks at the issue - it's already
                  # March 21st and the issue should be marked overdue
                  User.current = user_in_asia
                  assert issue.overdue?
                end
              end

test/unit/journal_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 JournalTest < ActiveSupport::TestCase
                fixtures :projects, :issues, :issue_statuses, :journals, :journal_details,
                         :issue_relations, :workflows,
                         :users, :members, :member_roles, :roles, :enabled_modules,
                         :groups_users, :email_addresses,
                         :enumerations,
                         :projects_trackers, :trackers, :custom_fields
                def setup
                  @journal = Journal.find 1
                  User.current = nil
                end
                def test_journalized_is_an_issue
                  issue = @journal.issue
                  assert_kind_of Issue, issue
                  assert_equal 1, issue.id
                end
                def test_new_status
                  status = @journal.new_status
                  assert_not_nil status
                  assert_kind_of IssueStatus, status
                  assert_equal 2, status.id
                end
                def test_create_should_send_email_notification
                  ActionMailer::Base.deliveries.clear
                  issue = Issue.first
                  user = User.first
                  journal = issue.init_journal(user, issue)
                  assert journal.save
                  assert_equal 1, ActionMailer::Base.deliveries.size
                end
                def test_should_not_save_journal_with_blank_notes_and_no_details
                  journal = Journal.new(:journalized => Issue.first, :user => User.first)
                  assert_no_difference 'Journal.count' do
                    assert_equal false, journal.save
                  end
                end
                def test_create_should_not_split_non_private_notes
                  assert_difference 'Journal.count' do
                    assert_no_difference 'JournalDetail.count' do
                      journal = Journal.generate!(:notes => 'Notes')
                    end
                  end
                  assert_difference 'Journal.count' do
                    assert_difference 'JournalDetail.count' do
                      journal = Journal.generate!(:notes => 'Notes', :details => [JournalDetail.new])
                    end
                  end
                  assert_difference 'Journal.count' do
                    assert_difference 'JournalDetail.count' do
                      journal = Journal.generate!(:notes => '', :details => [JournalDetail.new])
                    end
                  end
                end
                def test_create_should_split_private_notes
                  assert_difference 'Journal.count' do
                    assert_no_difference 'JournalDetail.count' do
                      journal = Journal.generate!(:notes => 'Notes', :private_notes => true)
                      journal.reload
                      assert_equal true, journal.private_notes
                      assert_equal 'Notes', journal.notes
                    end
                  end
                  assert_difference 'Journal.count', 2 do
                    assert_difference 'JournalDetail.count' do
                      journal = Journal.generate!(:notes => 'Notes', :private_notes => true, :details => [JournalDetail.new])
                      journal.reload
                      assert_equal true, journal.private_notes
                      assert_equal 'Notes', journal.notes
                      assert_equal 0, journal.details.size
                      journal_with_changes = Journal.order('id DESC').offset(1).first
                      assert_equal false, journal_with_changes.private_notes
                      assert_nil journal_with_changes.notes
                      assert_equal 1, journal_with_changes.details.size
                      assert_equal journal.created_on, journal_with_changes.created_on
                    end
                  end
                  assert_difference 'Journal.count' do
                    assert_difference 'JournalDetail.count' do
                      journal = Journal.generate!(:notes => '', :private_notes => true, :details => [JournalDetail.new])
                      journal.reload
                      assert_equal false, journal.private_notes
                      assert_equal '', journal.notes
                      assert_equal 1, journal.details.size
                    end
                  end
                end
                def test_visible_scope_for_anonymous
                  # Anonymous user should see issues of public projects only
                  journals = Journal.visible(User.anonymous).to_a
                  assert journals.any?
                  assert_nil journals.detect {|journal| !journal.issue.project.is_public?}
                  # Anonymous user should not see issues without permission
                  Role.anonymous.remove_permission!(:view_issues)
                  journals = Journal.visible(User.anonymous).to_a
                  assert journals.empty?
                end
                def test_visible_scope_for_user
                  user = User.find(9)
                  assert user.projects.empty?
                  # Non member user should see issues of public projects only
                  journals = Journal.visible(user).to_a
                  assert journals.any?
                  assert_nil journals.detect {|journal| !journal.issue.project.is_public?}
                  # Non member user should not see issues without permission
                  Role.non_member.remove_permission!(:view_issues)
                  user.reload
                  journals = Journal.visible(user).to_a
                  assert journals.empty?
                  # User should see issues of projects for which user has view_issues permissions only
                  Member.create!(:principal => user, :project_id => 1, :role_ids => [1])
                  user.reload
                  journals = Journal.visible(user).to_a
                  assert journals.any?
                  assert_nil journals.detect {|journal| journal.issue.project_id != 1}
                end
                def test_visible_scope_for_admin
                  user = User.find(1)
                  user.members.each(&:destroy)
                  assert user.projects.empty?
                  journals = Journal.visible(user).to_a
                  assert journals.any?
                  # Admin should see issues on private projects that admin does not belong to
                  assert journals.detect {|journal| !journal.issue.project.is_public?}
                end
                def test_preload_journals_details_custom_fields_should_set_custom_field_instance_variable
                  d = JournalDetail.new(:property => 'cf', :prop_key => '2')
                  journals = [Journal.new(:details => [d])]
                  d.expects(:instance_variable_set).with("@custom_field", CustomField.find(2)).once
                  Journal.preload_journals_details_custom_fields(journals)
                end
                def test_preload_journals_details_custom_fields_with_empty_set
                  assert_nothing_raised do
                    Journal.preload_journals_details_custom_fields([])
                  end
                end
                def test_details_should_normalize_dates
                  j = JournalDetail.create!(:old_value => Date.parse('2012-11-03'), :value => Date.parse('2013-01-02'))
                  j.reload
                  assert_equal '2012-11-03', j.old_value
                  assert_equal '2013-01-02', j.value
                end
                def test_details_should_normalize_true_values
                  j = JournalDetail.create!(:old_value => true, :value => true)
                  j.reload
                  assert_equal '1', j.old_value
                  assert_equal '1', j.value
                end
                def test_details_should_normalize_false_values
                  j = JournalDetail.create!(:old_value => false, :value => false)
                  j.reload
                  assert_equal '0', j.old_value
                  assert_equal '0', j.value
                end
                def test_custom_field_should_return_custom_field_for_cf_detail
                  d = JournalDetail.new(:property => 'cf', :prop_key => '2')
                  assert_equal CustomField.find(2), d.custom_field
                end
                def test_custom_field_should_return_nil_for_non_cf_detail
                  d = JournalDetail.new(:property => 'subject')
-                 assert_equal nil, d.custom_field
+                 assert_nil d.custom_field
                end
                def test_visible_details_should_include_relations_to_visible_issues_only
                  issue = Issue.generate!
                  visible_issue = Issue.generate!
                  hidden_issue = Issue.generate!(:is_private => true)
                  journal = Journal.new
                  journal.details << JournalDetail.new(:property => 'relation', :prop_key => 'relates', :value => visible_issue.id)
                  journal.details << JournalDetail.new(:property => 'relation', :prop_key => 'relates', :value => hidden_issue.id)
                  visible_details = journal.visible_details(User.anonymous)
                  assert_equal 1, visible_details.size
                  assert_equal visible_issue.id.to_s, visible_details.first.value.to_s
                  visible_details = journal.visible_details(User.find(2))
                  assert_equal 2, visible_details.size
                end
              end

test/unit/lib/redmine/codeset_util_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 Redmine::CodesetUtilTest < ActiveSupport::TestCase
                def test_to_utf8_by_setting_from_latin1
                  with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                    s1 = "Texte encod\xc3\xa9".force_encoding("UTF-8")
                    s2 = "Texte encod\xe9".force_encoding("ASCII-8BIT")
                    s3 = s2.dup.force_encoding("UTF-8")
                    assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s2)
                    assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s3)
                  end
                end
                def test_to_utf8_by_setting_from_euc_jp
                  with_settings :repositories_encodings => 'UTF-8,EUC-JP' do
                    s1 = "\xe3\x83\xac\xe3\x83\x83\xe3\x83\x89\xe3\x83\x9e\xe3\x82\xa4\xe3\x83\xb3".force_encoding("UTF-8")
                    s2 = "\xa5\xec\xa5\xc3\xa5\xc9\xa5\xde\xa5\xa4\xa5\xf3".force_encoding("ASCII-8BIT")
                    s3 = s2.dup.force_encoding("UTF-8")
                    assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s2)
                    assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s3)
                  end
                end
                def test_to_utf8_by_setting_should_be_converted_all_latin1
                  with_settings :repositories_encodings => 'ISO-8859-1' do
                    s1 = "\xc3\x82\xc2\x80".force_encoding("UTF-8")
                    s2 = "\xC2\x80".force_encoding("ASCII-8BIT")
                    s3 = s2.dup.force_encoding("UTF-8")
                    assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s2)
                    assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s3)
                  end
                end
                def test_to_utf8_by_setting_blank_string
                  assert_equal "",  Redmine::CodesetUtil.to_utf8_by_setting("")
-                 assert_equal nil, Redmine::CodesetUtil.to_utf8_by_setting(nil)
+                 assert_nil Redmine::CodesetUtil.to_utf8_by_setting(nil)
                end
                def test_to_utf8_by_setting_returns_ascii_as_utf8
                  s1 = "ASCII".force_encoding("UTF-8")
                  s2 = s1.dup.force_encoding("ISO-8859-1")
                  str1 = Redmine::CodesetUtil.to_utf8_by_setting(s1)
                  str2 = Redmine::CodesetUtil.to_utf8_by_setting(s2)
                  assert_equal s1, str1
                  assert_equal s1, str2
                  assert_equal "UTF-8", str1.encoding.to_s
                  assert_equal "UTF-8", str2.encoding.to_s
                end
                def test_to_utf8_by_setting_invalid_utf8_sequences_should_be_stripped
                  with_settings :repositories_encodings => '' do
                    # s1 = File.read("#{RAILS_ROOT}/test/fixtures/encoding/iso-8859-1.txt")
                    s1 = "Texte encod\xe9 en ISO-8859-1.".force_encoding("ASCII-8BIT")
                    str = Redmine::CodesetUtil.to_utf8_by_setting(s1)
                    assert str.valid_encoding?
                    assert_equal "UTF-8", str.encoding.to_s
                    assert_equal "Texte encod? en ISO-8859-1.", str
                  end
                end
                def test_to_utf8_by_setting_invalid_utf8_sequences_should_be_stripped_ja_jis
                  with_settings :repositories_encodings => 'ISO-2022-JP' do
                    s1 = "test\xb5\xfetest\xb5\xfe".force_encoding("ASCII-8BIT")
                    str = Redmine::CodesetUtil.to_utf8_by_setting(s1)
                    assert str.valid_encoding?
                    assert_equal "UTF-8", str.encoding.to_s
                    assert_equal "test??test??", str
                  end
                end
              end

test/unit/lib/redmine/export/pdf_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 PdfTest < ActiveSupport::TestCase
                fixtures :users, :projects, :roles, :members, :member_roles,
                         :enabled_modules, :issues, :trackers, :attachments
                def test_fix_text_encoding_nil
                  assert_equal '', Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(nil, "UTF-8")
                  assert_equal '', Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(nil, "ISO-8859-1")
                end
                def test_rdm_pdf_iconv_cannot_convert_ja_cp932
                  utf8_txt_1  = "\xe7\x8b\x80\xe6\x85\x8b"
                  utf8_txt_2  = "\xe7\x8b\x80\xe6\x85\x8b\xe7\x8b\x80"
                  utf8_txt_3  = "\xe7\x8b\x80\xe7\x8b\x80\xe6\x85\x8b\xe7\x8b\x80"
                  ["CP932", "SJIS"].each do |encoding|
                    txt_1 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_1, encoding)
                    txt_2 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_2, encoding)
                    txt_3 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_3, encoding)
                    assert_equal "?\x91\xd4".force_encoding("ASCII-8BIT"), txt_1
                    assert_equal "?\x91\xd4?".force_encoding("ASCII-8BIT"), txt_2
                    assert_equal "??\x91\xd4?".force_encoding("ASCII-8BIT"), txt_3
                    assert_equal "ASCII-8BIT", txt_1.encoding.to_s
                    assert_equal "ASCII-8BIT", txt_2.encoding.to_s
                    assert_equal "ASCII-8BIT", txt_3.encoding.to_s
                  end
                end
                def test_rdm_pdf_iconv_invalid_utf8_should_be_replaced_en
                  str1 = "Texte encod\xe9 en ISO-8859-1".force_encoding("UTF-8")
                  str2 = "\xe9a\xe9b\xe9c\xe9d\xe9e test".force_encoding("ASCII-8BIT")
                  txt_1 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str1, 'UTF-8')
                  txt_2 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str2, 'UTF-8')
                  assert_equal "ASCII-8BIT", txt_1.encoding.to_s
                  assert_equal "ASCII-8BIT", txt_2.encoding.to_s
                  assert_equal "Texte encod? en ISO-8859-1", txt_1
                  assert_equal "?a?b?c?d?e test", txt_2
                end
                def test_rdm_pdf_iconv_invalid_utf8_should_be_replaced_ja
                  str1 = "Texte encod\xe9 en ISO-8859-1".force_encoding("UTF-8")
                  str2 = "\xe9a\xe9b\xe9c\xe9d\xe9e test".force_encoding("ASCII-8BIT")
                  encoding = ( RUBY_PLATFORM == 'java' ? "SJIS" : "CP932" )
                  txt_1 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str1, encoding)
                  txt_2 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str2, encoding)
                  assert_equal "ASCII-8BIT", txt_1.encoding.to_s
                  assert_equal "ASCII-8BIT", txt_2.encoding.to_s
                  assert_equal "Texte encod? en ISO-8859-1", txt_1
                  assert_equal "?a?b?c?d?e test", txt_2
                end
                def test_attach
                  ["CP932", "SJIS"].each do |encoding|
                    set_fixtures_attachments_directory
                    str2 = "\x83e\x83X\x83g".force_encoding("ASCII-8BIT")
                    a1 = Attachment.find(17)
                    a2 = Attachment.find(19)
                    User.current = User.find(1)
                    assert a1.readable?
                    assert a1.visible?
                    assert a2.readable?
                    assert a2.visible?
                    aa1 = Redmine::Export::PDF::RDMPdfEncoding::attach(Attachment.all, "Testfile.PNG", "UTF-8")
                    assert_not_nil aa1
                    assert_equal 17, aa1.id
                    aa2 = Redmine::Export::PDF::RDMPdfEncoding::attach(Attachment.all, "test#{str2}.png", encoding)
                    assert_not_nil aa2
                    assert_equal 19, aa2.id
                    User.current = nil
                    assert a1.readable?
                    assert (! a1.visible?)
                    assert a2.readable?
                    assert (! a2.visible?)
                    aa1 = Redmine::Export::PDF::RDMPdfEncoding::attach(Attachment.all, "Testfile.PNG", "UTF-8")
-                   assert_equal nil, aa1
+                   assert_nil aa1
                    aa2 = Redmine::Export::PDF::RDMPdfEncoding::attach(Attachment.all, "test#{str2}.png", encoding)
-                   assert_equal nil, aa2
+                   assert_nil aa2
                    set_tmp_attachments_directory
                  end
                end
              end

test/unit/lib/redmine/menu_manager/mapper_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 Redmine::MenuManager::MapperTest < ActiveSupport::TestCase
                test "Mapper#initialize should define a root MenuNode if menu is not present in items" do
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  node = menu_mapper.menu_items
                  assert_not_nil node
                  assert_equal :root, node.name
                end
                test "Mapper#initialize should use existing MenuNode if present" do
                  node = "foo" # just an arbitrary reference
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {:test_menu => node})
                  assert_equal node, menu_mapper.menu_items
                end
                def test_push_onto_root
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_overview, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.exists?(:test_overview)
                end
                def test_push_onto_parent
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_overview, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_child, { :controller => 'projects', :action => 'show'}, {:parent => :test_overview}
                  assert menu_mapper.exists?(:test_child)
                  assert_equal :test_child, menu_mapper.find(:test_child).name
                end
                def test_push_onto_grandparent
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_overview, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_child, { :controller => 'projects', :action => 'show'}, {:parent => :test_overview}
                  menu_mapper.push :test_grandchild, { :controller => 'projects', :action => 'show'}, {:parent => :test_child}
                  assert menu_mapper.exists?(:test_grandchild)
                  grandchild = menu_mapper.find(:test_grandchild)
                  assert_equal :test_grandchild, grandchild.name
                  assert_equal :test_child, grandchild.parent.name
                end
                def test_push_first
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_second, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_third, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_fourth, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_fifth, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_first, { :controller => 'projects', :action => 'show'}, {:first => true}
                  root = menu_mapper.find(:root)
                  assert_equal 5, root.children.size
                  {0 => :test_first, 1 => :test_second, 2 => :test_third, 3 => :test_fourth, 4 => :test_fifth}.each do |position, name|
                    assert_not_nil root.children[position]
                    assert_equal name, root.children[position].name
                  end
                end
                def test_push_before
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_first, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_second, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_fourth, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_fifth, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_third, { :controller => 'projects', :action => 'show'}, {:before => :test_fourth}
                  root = menu_mapper.find(:root)
                  assert_equal 5, root.children.size
                  {0 => :test_first, 1 => :test_second, 2 => :test_third, 3 => :test_fourth, 4 => :test_fifth}.each do |position, name|
                    assert_not_nil root.children[position]
                    assert_equal name, root.children[position].name
                  end
                end
                def test_push_after
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_first, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_second, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_third, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_fifth, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_fourth, { :controller => 'projects', :action => 'show'}, {:after => :test_third}
                  root = menu_mapper.find(:root)
                  assert_equal 5, root.children.size
                  {0 => :test_first, 1 => :test_second, 2 => :test_third, 3 => :test_fourth, 4 => :test_fifth}.each do |position, name|
                    assert_not_nil root.children[position]
                    assert_equal name, root.children[position].name
                  end
                end
                def test_push_last
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_first, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_second, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_third, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_fifth, { :controller => 'projects', :action => 'show'}, {:last => true}
                  menu_mapper.push :test_fourth, { :controller => 'projects', :action => 'show'}, {}
                  root = menu_mapper.find(:root)
                  assert_equal 5, root.children.size
                  {0 => :test_first, 1 => :test_second, 2 => :test_third, 3 => :test_fourth, 4 => :test_fifth}.each do |position, name|
                    assert_not_nil root.children[position]
                    assert_equal name, root.children[position].name
                  end
                end
                def test_exists_for_child_node
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_overview, { :controller => 'projects', :action => 'show'}, {}
                  menu_mapper.push :test_child, { :controller => 'projects', :action => 'show'}, {:parent => :test_overview }
                  assert menu_mapper.exists?(:test_child)
                end
                def test_exists_for_invalid_node
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_overview, { :controller => 'projects', :action => 'show'}, {}
                  assert !menu_mapper.exists?(:nothing)
                end
                def test_find
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_overview, { :controller => 'projects', :action => 'show'}, {}
                  item = menu_mapper.find(:test_overview)
                  assert_equal :test_overview, item.name
                  assert_equal({:controller => 'projects', :action => 'show'}, item.url)
                end
                def test_find_missing
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_overview, { :controller => 'projects', :action => 'show'}, {}
                  item = menu_mapper.find(:nothing)
-                 assert_equal nil, item
+                 assert_nil item
                end
                def test_delete
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  menu_mapper.push :test_overview, { :controller => 'projects', :action => 'show'}, {}
                  assert_not_nil menu_mapper.delete(:test_overview)
                  assert_nil menu_mapper.find(:test_overview)
                end
                def test_delete_missing
                  menu_mapper = Redmine::MenuManager::Mapper.new(:test_menu, {})
                  assert_nil menu_mapper.delete(:test_missing)
                end
                test 'deleting all items' do
                  # Exposed by deleting :last items
                  Redmine::MenuManager.map :test_menu do |menu|
                    menu.push :not_last, Redmine::Info.help_url
                    menu.push :administration, { :controller => 'projects', :action => 'show'}, {:last => true}
                    menu.push :help, Redmine::Info.help_url, :last => true
                  end
                  assert_nothing_raised do
                    Redmine::MenuManager.map :test_menu do |menu|
                      menu.delete(:administration)
                      menu.delete(:help)
                      menu.push :test_overview, { :controller => 'projects', :action => 'show'}, {}
                   end
                  end
                end
              end

test/unit/lib/redmine/scm/adapters/git_adapter_test.rb +3 -3

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 GitAdapterTest < ActiveSupport::TestCase
                REPOSITORY_PATH = Rails.root.join('tmp/test/git_repository').to_s
                FELIX_HEX  = "Felix Sch\xC3\xA4fer"
                CHAR_1_HEX = "\xc3\x9c"
                ## Git, Mercurial and CVS path encodings are binary.
                ## Subversion supports URL encoding for path.
                ## Redmine Mercurial adapter and extension use URL encoding.
                ## Git accepts only binary path in command line parameter.
                ## So, there is no way to use binary command line parameter in JRuby.
                JRUBY_SKIP     = (RUBY_PLATFORM == 'java')
                JRUBY_SKIP_STR = "TODO: This test fails in JRuby"
                if File.directory?(REPOSITORY_PATH)
                  ## Ruby uses ANSI api to fork a process on Windows.
                  ## Japanese Shift_JIS and Traditional Chinese Big5 have 0x5c(backslash) problem
                  ## and these are incompatible with ASCII.
                  ## Git for Windows (msysGit) changed internal API from ANSI to Unicode in 1.7.10
                  ## http://code.google.com/p/msysgit/issues/detail?id=80
                  ## So, Latin-1 path tests fail on Japanese Windows
                  WINDOWS_PASS = (Redmine::Platform.mswin? &&
                                  Redmine::Scm::Adapters::GitAdapter.client_version_above?([1, 7, 10]))
                  WINDOWS_SKIP_STR = "TODO: This test fails in Git for Windows above 1.7.10"
                  def setup
                    adapter_class = Redmine::Scm::Adapters::GitAdapter
                    assert adapter_class
                    assert adapter_class.client_command
                    assert_equal true, adapter_class.client_available
                    assert_equal true, adapter_class.client_version_above?([1])
                    assert_equal true, adapter_class.client_version_above?([1, 0])
                    @adapter = Redmine::Scm::Adapters::GitAdapter.new(
                                  REPOSITORY_PATH,
                                  nil,
                                  nil,
                                  nil,
                                  'ISO-8859-1'
                               )
                    assert @adapter
                    @char_1 = CHAR_1_HEX.dup.force_encoding('UTF-8')
                    @str_felix_hex  = FELIX_HEX.dup.force_encoding('ASCII-8BIT')
                  end
                  def test_scm_version
                    to_test = { "git version 1.7.3.4\n"             => [1,7,3,4],
                                "1.6.1\n1.7\n1.8"                   => [1,6,1],
                                "1.6.2\r\n1.8.1\r\n1.9.1"           => [1,6,2]}
                    to_test.each do |s, v|
                      test_scm_version_for(s, v)
                    end
                  end
                  def test_branches
                    brs = []
                    @adapter.branches.each do |b|
                      brs << b
                    end
                    assert_equal 6, brs.length
                    br_issue_8857 = brs[0]
                    assert_equal 'issue-8857', br_issue_8857.to_s
                    assert_equal '2a682156a3b6e77a8bf9cd4590e8db757f3c6c78', br_issue_8857.revision
                    assert_equal br_issue_8857.scmid, br_issue_8857.revision
                    assert_equal false, br_issue_8857.is_default
                    br_latin_1_path = brs[1]
                    assert_equal 'latin-1-path-encoding', br_latin_1_path.to_s
                    assert_equal '1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127', br_latin_1_path.revision
                    assert_equal br_latin_1_path.scmid, br_latin_1_path.revision
                    assert_equal false, br_latin_1_path.is_default
                    br_master = brs[2]
                    assert_equal 'master', br_master.to_s
                    assert_equal '83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', br_master.revision
                    assert_equal br_master.scmid, br_master.revision
                    assert_equal false, br_master.is_default
                    br_master_20120212 = brs[3]
                    assert_equal 'master-20120212', br_master_20120212.to_s
                    assert_equal '83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', br_master_20120212.revision
                    assert_equal br_master_20120212.scmid, br_master_20120212.revision
                    assert_equal true, br_master_20120212.is_default
                    br_latin_1 = brs[-2]
                    assert_equal 'test-latin-1', br_latin_1.to_s
                    assert_equal '67e7792ce20ccae2e4bb73eed09bb397819c8834', br_latin_1.revision
                    assert_equal br_latin_1.scmid, br_latin_1.revision
                    assert_equal false, br_latin_1.is_default
                    br_test = brs[-1]
                    assert_equal 'test_branch', br_test.to_s
                    assert_equal 'fba357b886984ee71185ad2065e65fc0417d9b92', br_test.revision
                    assert_equal br_test.scmid, br_test.revision
                    assert_equal false, br_test.is_default
                  end
                  def test_default_branch
                    assert_equal 'master-20120212', @adapter.default_branch
                  end
                  def test_tags
                    assert_equal  [
                          "tag00.lightweight",
                          "tag01.annotated",
                        ], @adapter.tags
                  end
                  def test_revisions_master_all
                    revs1 = []
                    @adapter.revisions('', nil, "master",{}) do |rev|
                      revs1 << rev
                    end
                    assert_equal 15, revs1.length
                    assert_equal '83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', revs1[ 0].identifier
                    assert_equal '7234cb2750b63f47bff735edc50a1c0a433c2518', revs1[-1].identifier
                    revs2 = []
                    @adapter.revisions('', nil, "master",
                                       {:reverse => true}) do |rev|
                      revs2 << rev
                    end
                    assert_equal 15, revs2.length
                    assert_equal '83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', revs2[-1].identifier
                    assert_equal '7234cb2750b63f47bff735edc50a1c0a433c2518', revs2[ 0].identifier
                  end
                  def test_revisions_master_merged_rev
                    revs1 = []
                    @adapter.revisions('',
                                       "713f4944648826f558cf548222f813dabe7cbb04",
                                       "master",
                                       {:reverse => true}) do |rev|
                      revs1 << rev
                    end
                    assert_equal 8, revs1.length
                    assert_equal 'fba357b886984ee71185ad2065e65fc0417d9b92', revs1[ 0].identifier
                    assert_equal '7e61ac704deecde634b51e59daa8110435dcb3da', revs1[ 1].identifier
                    # 4a07fe31b is not a child of 713f49446
                    assert_equal '4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8', revs1[ 2].identifier
                    # Merged revision
                    assert_equal '32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf', revs1[ 3].identifier
                    assert_equal '83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', revs1[-1].identifier
                    revs2 = []
                    @adapter.revisions('',
                                       "fba357b886984ee71185ad2065e65fc0417d9b92",
                                       "master",
                                       {:reverse => true}) do |rev|
                      revs2 << rev
                    end
                    assert_equal 7, revs2.length
                    assert_equal '7e61ac704deecde634b51e59daa8110435dcb3da', revs2[ 0].identifier
                    # 4a07fe31b is not a child of fba357b8869
                    assert_equal '4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8', revs2[ 1].identifier
                    # Merged revision
                    assert_equal '32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf', revs2[ 2].identifier
                    assert_equal '83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', revs2[-1].identifier
                  end
                  def test_revisions_branch_latin_1_path_encoding_all
                    revs1 = []
                    @adapter.revisions('', nil, "latin-1-path-encoding",{}) do |rev|
                      revs1 << rev
                    end
                    assert_equal 8, revs1.length
                    assert_equal '1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127', revs1[ 0].identifier
                    assert_equal '7234cb2750b63f47bff735edc50a1c0a433c2518', revs1[-1].identifier
                    revs2 = []
                    @adapter.revisions('', nil, "latin-1-path-encoding",
                                       {:reverse => true}) do |rev|
                      revs2 << rev
                    end
                    assert_equal 8, revs2.length
                    assert_equal '1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127', revs2[-1].identifier
                    assert_equal '7234cb2750b63f47bff735edc50a1c0a433c2518', revs2[ 0].identifier
                  end
                  def test_revisions_branch_latin_1_path_encoding_with_rev
                    revs1 = []
                    @adapter.revisions('',
                                       '7234cb2750b63f47bff735edc50a1c0a433c2518',
                                       "latin-1-path-encoding",
                                       {:reverse => true}) do |rev|
                      revs1 << rev
                    end
                    assert_equal 7, revs1.length
                    assert_equal '899a15dba03a3b350b89c3f537e4bbe02a03cdc9', revs1[ 0].identifier
                    assert_equal '1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127', revs1[-1].identifier
                    revs2 = []
                    @adapter.revisions('',
                                       '57ca437c0acbbcb749821fdf3726a1367056d364',
                                       "latin-1-path-encoding",
                                       {:reverse => true}) do |rev|
                      revs2 << rev
                    end
                    assert_equal 3, revs2.length
                    assert_equal '4fc55c43bf3d3dc2efb66145365ddc17639ce81e', revs2[ 0].identifier
                    assert_equal '1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127', revs2[-1].identifier
                  end
                  def test_revisions_invalid_rev
                    assert_equal [], @adapter.revisions('', '1234abcd', "master")
                    assert_raise Redmine::Scm::Adapters::CommandFailed do
                      revs1 = []
                      @adapter.revisions('',
                                       '1234abcd',
                                       "master",
                                       {:reverse => true}) do |rev|
                        revs1 << rev
                      end
                    end
                  end
                  def test_revisions_includes_master_two_revs
                    revs1 = []
                    @adapter.revisions('', nil, nil,
                                       {:reverse => true,
                                        :includes => ['83ca5fd546063a3c7dc2e568ba3355661a9e2b2c'],
                                        :excludes => ['4f26664364207fa8b1af9f8722647ab2d4ac5d43']}) do |rev|
                      revs1 << rev
                    end
                    assert_equal 2, revs1.length
                    assert_equal 'ed5bb786bbda2dee66a2d50faf51429dbc043a7b', revs1[ 0].identifier
                    assert_equal '83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', revs1[-1].identifier
                  end
                  def test_revisions_includes_master_two_revs_from_origin
                    revs1 = []
                    @adapter.revisions('', nil, nil,
                                       {:reverse => true,
                                        :includes => ['899a15dba03a3b350b89c3f537e4bbe02a03cdc9'],
                                        :excludes => []}) do |rev|
                      revs1 << rev
                    end
                    assert_equal 2, revs1.length
                    assert_equal '7234cb2750b63f47bff735edc50a1c0a433c2518', revs1[ 0].identifier
                    assert_equal '899a15dba03a3b350b89c3f537e4bbe02a03cdc9', revs1[ 1].identifier
                  end
                  def test_revisions_includes_merged_revs
                    revs1 = []
                    @adapter.revisions('', nil, nil,
                                       {:reverse => true,
                                        :includes => ['83ca5fd546063a3c7dc2e568ba3355661a9e2b2c'],
                                        :excludes => ['fba357b886984ee71185ad2065e65fc0417d9b92']}) do |rev|
                      revs1 << rev
                    end
                    assert_equal 7, revs1.length
                    assert_equal '7e61ac704deecde634b51e59daa8110435dcb3da', revs1[ 0].identifier
                    assert_equal '4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8', revs1[ 1].identifier
                    assert_equal '32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf', revs1[ 2].identifier
                    assert_equal '83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', revs1[-1].identifier
                  end
                  def test_revisions_includes_two_heads
                    revs1 = []
                    @adapter.revisions('', nil, nil,
                                       {:reverse => true,
                                        :includes => ['83ca5fd546063a3c7dc2e568ba3355661a9e2b2c',
                                                      '1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127'],
                                        :excludes => ['4f26664364207fa8b1af9f8722647ab2d4ac5d43',
                                                      '4fc55c43bf3d3dc2efb66145365ddc17639ce81e']}) do |rev|
                      revs1 << rev
                    end
                    assert_equal 4, revs1.length
                    assert_equal 'ed5bb786bbda2dee66a2d50faf51429dbc043a7b', revs1[ 0].identifier
                    assert_equal '83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', revs1[ 1].identifier
                    assert_equal '64f1f3e89ad1cb57976ff0ad99a107012ba3481d', revs1[-2].identifier
                    assert_equal '1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127', revs1[-1].identifier
                  end
                  def test_revisions_disjointed_histories_revisions
                    revs1 = []
                    @adapter.revisions('', nil, nil,
                                       {:reverse => true,
                                        :includes => ['83ca5fd546063a3c7dc2e568ba3355661a9e2b2c',
                                                      '92397af84d22f27389c822848ecd5b463c181583'],
                                        :excludes => ['95488a44bc25f7d1f97d775a31359539ff333a63',
                                                      '4f26664364207fa8b1af9f8722647ab2d4ac5d43'] }) do |rev|
                      revs1 << rev
                    end
                    assert_equal 4, revs1.length
                    assert_equal 'ed5bb786bbda2dee66a2d50faf51429dbc043a7b', revs1[ 0].identifier
                    assert_equal '83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', revs1[ 1].identifier
                    assert_equal 'bc201c95999c4f10d018b0aa03b541cd6a2ff0ee', revs1[-2].identifier
                    assert_equal '92397af84d22f27389c822848ecd5b463c181583', revs1[-1].identifier
                  end
                  def test_revisions_invalid_rev_excludes
                    assert_equal [],
                                 @adapter.revisions('', nil, nil,
                                                    {:reverse => true,
                                                     :includes => ['83ca5fd546063a3c7dc2e568ba3355661a9e2b2c'],
                                                     :excludes => ['0123abcd4567']})
                    assert_raise Redmine::Scm::Adapters::CommandFailed do
                      revs1 = []
                      @adapter.revisions('', nil, nil,
                                         {:reverse => true,
                                          :includes => ['83ca5fd546063a3c7dc2e568ba3355661a9e2b2c'],
                                          :excludes => ['0123abcd4567']}) do |rev|
                        revs1 << rev
                      end
                    end
                  end
                  def test_getting_revisions_with_spaces_in_filename
                    assert_equal 1, @adapter.revisions("filemane with spaces.txt",
                                                       nil, "master").length
                  end
                  def test_parents
                    revs1 = []
                    @adapter.revisions('',
                                       nil,
                                       "master",
                                       {:reverse => true}) do |rev|
                      revs1 << rev
                    end
                    assert_equal 15, revs1.length
                    assert_equal "7234cb2750b63f47bff735edc50a1c0a433c2518",
                                 revs1[0].identifier
-                   assert_equal nil, revs1[0].parents
+                   assert_nil revs1[0].parents
                    assert_equal "899a15dba03a3b350b89c3f537e4bbe02a03cdc9",
                                 revs1[1].identifier
                    assert_equal 1, revs1[1].parents.length
                    assert_equal "7234cb2750b63f47bff735edc50a1c0a433c2518",
                                 revs1[1].parents[0]
                    assert_equal "32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf",
                                 revs1[10].identifier
                    assert_equal 2, revs1[10].parents.length
                    assert_equal "4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8",
                                 revs1[10].parents[0]
                    assert_equal "7e61ac704deecde634b51e59daa8110435dcb3da",
                                 revs1[10].parents[1]
                  end
                  def test_getting_revisions_with_leading_and_trailing_spaces_in_filename
                    assert_equal " filename with a leading space.txt ",
                       @adapter.revisions(" filename with a leading space.txt ",
                                           nil, "master")[0].paths[0][:path]
                  end
                  def test_getting_entries_with_leading_and_trailing_spaces_in_filename
                    assert_equal " filename with a leading space.txt ",
                       @adapter.entries('',
                               '83ca5fd546063a3c7dc2e568ba3355661a9e2b2c')[3].name
                  end
                  def test_annotate
                    annotate = @adapter.annotate('sources/watchers_controller.rb')
                    assert_kind_of Redmine::Scm::Adapters::Annotate, annotate
                    assert_equal 41, annotate.lines.size
                    assert_equal "# This program is free software; you can redistribute it and/or",
                                 annotate.lines[4].strip
                    assert_equal "7234cb2750b63f47bff735edc50a1c0a433c2518",
                                  annotate.revisions[4].identifier
                    assert_equal "jsmith", annotate.revisions[4].author
                  end
                  def test_annotate_moved_file
                    annotate = @adapter.annotate('renamed_test.txt')
                    assert_kind_of Redmine::Scm::Adapters::Annotate, annotate
                    assert_equal 2, annotate.lines.size
                  end
                  def test_last_rev
                    last_rev = @adapter.lastrev("README",
                                                "4f26664364207fa8b1af9f8722647ab2d4ac5d43")
                    assert_equal "4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8", last_rev.scmid
                    assert_equal "4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8", last_rev.identifier
                    assert_equal "Adam Soltys <asoltys@gmail.com>", last_rev.author
                    assert_equal Time.gm(2009, 6, 24, 5, 27, 38), last_rev.time
                  end
                  def test_last_rev_with_spaces_in_filename
                    last_rev = @adapter.lastrev("filemane with spaces.txt",
                                                "ed5bb786bbda2dee66a2d50faf51429dbc043a7b")
                    last_rev_author = last_rev.author
                    assert_equal "ed5bb786bbda2dee66a2d50faf51429dbc043a7b", last_rev.scmid
                    assert_equal "ed5bb786bbda2dee66a2d50faf51429dbc043a7b", last_rev.identifier
                    assert_equal "#{@str_felix_hex} <felix@fachschaften.org>",
                                   last_rev.author
                    assert_equal Time.gm(2010, 9, 18, 19, 59, 46), last_rev.time
                  end
                  def test_latin_1_path
                    if WINDOWS_PASS
                      puts WINDOWS_SKIP_STR
                    elsif JRUBY_SKIP
                      puts JRUBY_SKIP_STR
                    else
                      p2 = "latin-1-dir/test-#{@char_1}-2.txt"
                      ['4fc55c43bf3d3dc2efb66145365ddc17639ce81e', '4fc55c43bf3'].each do |r1|
                        assert @adapter.diff(p2, r1)
                        assert @adapter.cat(p2, r1)
                        assert_equal 1, @adapter.annotate(p2, r1).lines.length
                        ['64f1f3e89ad1cb57976ff0ad99a107012ba3481d', '64f1f3e89ad1cb5797'].each do |r2|
                          assert @adapter.diff(p2, r1, r2)
                        end
                      end
                    end
                  end
                  def test_latin_1_user_annotate
                    ['83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', '83ca5fd546063a'].each do |r1|
                      annotate = @adapter.annotate(" filename with a leading space.txt ", r1)
                      assert_kind_of Redmine::Scm::Adapters::Annotate, annotate
                      assert_equal 1, annotate.lines.size
                      assert_equal "And this is a file with a leading and trailing space...",
                                   annotate.lines[0].strip
                      assert_equal "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c",
                                   annotate.revisions[0].identifier
                      assert_equal @str_felix_hex, annotate.revisions[0].author
                    end
                  end
                  def test_entries_tag
                    entries1 = @adapter.entries(nil, 'tag01.annotated',
                                                options = {:report_last_commit => true})
                    assert entries1
                    assert_equal 3, entries1.size
                    assert_equal 'sources', entries1[1].name
                    assert_equal 'sources', entries1[1].path
                    assert_equal 'dir', entries1[1].kind
                    readme = entries1[2]
                    assert_equal 'README', readme.name
                    assert_equal 'README', readme.path
                    assert_equal 'file', readme.kind
                    assert_equal 27, readme.size
                    assert_equal '899a15dba03a3b350b89c3f537e4bbe02a03cdc9', readme.lastrev.identifier
                    assert_equal Time.gm(2007, 12, 14, 9, 24, 1), readme.lastrev.time
                  end
                  def test_entries_branch
                    entries1 = @adapter.entries(nil, 'test_branch',
                                                options = {:report_last_commit => true})
                    assert entries1
                    assert_equal 4, entries1.size
                    assert_equal 'sources', entries1[1].name
                    assert_equal 'sources', entries1[1].path
                    assert_equal 'dir', entries1[1].kind
                    readme = entries1[2]
                    assert_equal 'README', readme.name
                    assert_equal 'README', readme.path
                    assert_equal 'file', readme.kind
                    assert_equal 159, readme.size
                    assert_equal '713f4944648826f558cf548222f813dabe7cbb04', readme.lastrev.identifier
                    assert_equal Time.gm(2009, 6, 19, 4, 37, 23), readme.lastrev.time
                  end
                  def test_entries_wrong_path_encoding
                    adpt = Redmine::Scm::Adapters::GitAdapter.new(
                                  REPOSITORY_PATH,
                                  nil,
                                  nil,
                                  nil,
                                  'EUC-JP'
                               )
                    entries1 = adpt.entries('latin-1-dir', '64f1f3e8')
                    assert entries1
                    assert_equal 3, entries1.size
                    f1 = entries1[1]
-                   assert_equal nil, f1.name
-                   assert_equal nil, f1.path
+                   assert_nil f1.name
+                   assert_nil f1.path
                    assert_equal 'file', f1.kind
                  end
                  def test_entries_latin_1_files
                    entries1 = @adapter.entries('latin-1-dir', '64f1f3e8')
                    assert entries1
                    assert_equal 3, entries1.size
                    f1 = entries1[1]
                    assert_equal "test-#{@char_1}-2.txt", f1.name
                    assert_equal "latin-1-dir/test-#{@char_1}-2.txt", f1.path
                    assert_equal 'file', f1.kind
                  end
                  def test_entries_latin_1_dir
                    if WINDOWS_PASS
                      puts WINDOWS_SKIP_STR
                    elsif JRUBY_SKIP
                      puts JRUBY_SKIP_STR
                    else
                      entries1 = @adapter.entries("latin-1-dir/test-#{@char_1}-subdir",
                                                  '1ca7f5ed')
                      assert entries1
                      assert_equal 3, entries1.size
                      f1 = entries1[1]
                      assert_equal "test-#{@char_1}-2.txt", f1.name
                      assert_equal "latin-1-dir/test-#{@char_1}-subdir/test-#{@char_1}-2.txt", f1.path
                      assert_equal 'file', f1.kind
                    end
                  end
                  def test_entry
                    entry = @adapter.entry()
                    assert_equal "", entry.path
                    assert_equal "dir", entry.kind
                    entry = @adapter.entry('')
                    assert_equal "", entry.path
                    assert_equal "dir", entry.kind
                    assert_nil @adapter.entry('invalid')
                    assert_nil @adapter.entry('/invalid')
                    assert_nil @adapter.entry('/invalid/')
                    assert_nil @adapter.entry('invalid/invalid')
                    assert_nil @adapter.entry('invalid/invalid/')
                    assert_nil @adapter.entry('/invalid/invalid')
                    assert_nil @adapter.entry('/invalid/invalid/')
                    ["README", "/README"].each do |path|
                      entry = @adapter.entry(path, '7234cb2750b63f')
                      assert_equal "README", entry.path
                      assert_equal "file", entry.kind
                    end
                    ["sources", "/sources", "/sources/"].each do |path|
                      entry = @adapter.entry(path, '7234cb2750b63f')
                      assert_equal "sources", entry.path
                      assert_equal "dir", entry.kind
                    end
                    ["sources/watchers_controller.rb", "/sources/watchers_controller.rb"].each do |path|
                      entry = @adapter.entry(path, '7234cb2750b63f')
                      assert_equal "sources/watchers_controller.rb", entry.path
                      assert_equal "file", entry.kind
                    end
                  end
                  def test_path_encoding_default_utf8
                    adpt1 = Redmine::Scm::Adapters::GitAdapter.new(
                                              REPOSITORY_PATH
                                            )
                    assert_equal "UTF-8", adpt1.path_encoding
                    adpt2 = Redmine::Scm::Adapters::GitAdapter.new(
                                              REPOSITORY_PATH,
                                              nil,
                                              nil,
                                              nil,
                                              ""
                                            )
                    assert_equal "UTF-8", adpt2.path_encoding
                  end
                  def test_cat_path_invalid
                    assert_nil @adapter.cat('invalid')
                  end
                  def test_cat_revision_invalid
                    assert     @adapter.cat('README')
                    assert_nil @adapter.cat('README', '1234abcd5678')
                  end
                  def test_diff_path_invalid
                    assert_equal [], @adapter.diff('invalid', '713f4944648826f5')
                  end
                  def test_diff_revision_invalid
                    assert_nil @adapter.diff(nil, '1234abcd5678')
                    assert_nil @adapter.diff(nil, '713f4944648826f5', '1234abcd5678')
                    assert_nil @adapter.diff(nil, '1234abcd5678', '713f4944648826f5')
                  end
                  def test_annotate_path_invalid
                    assert_nil @adapter.annotate('invalid')
                  end
                  def test_annotate_revision_invalid
                    assert     @adapter.annotate('README')
                    assert_nil @adapter.annotate('README', '1234abcd5678')
                  end
                  private
                  def test_scm_version_for(scm_command_version, version)
                    @adapter.class.expects(:scm_version_from_command_line).returns(scm_command_version)
                    assert_equal version, @adapter.class.scm_command_version
                  end
                else
                  puts "Git test repository NOT FOUND. Skipping unit tests !!!"
                  def test_fake; assert true end
                end
              end

test/unit/project_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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,
                         :versions,
                         :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,
                         :groups_users,
                         :boards, :messages,
                         :repositories,
                         :news, :comments,
                         :documents,
                         :workflows
                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
                end
                def test_default_trackers_should_match_default_tracker_ids_setting
                  with_settings :default_projects_tracker_ids => ['1', '3'] do
                    assert_equal Tracker.find(1, 3).sort, Project.new.trackers.sort
                  end
                end
                def test_default_trackers_should_be_all_trackers_with_blank_setting
                  with_settings :default_projects_tracker_ids => nil do
                    assert_equal Tracker.all.sort, Project.new.trackers.sort
                  end
                end
                def test_default_trackers_should_be_empty_with_empty_setting
                  with_settings :default_projects_tracker_ids => [] do
                    assert_equal [], Project.new.trackers
                  end
                end
                def test_default_trackers_should_not_replace_initialized_trackers
                  with_settings :default_projects_tracker_ids => ['1', '3'] do
                    assert_equal Tracker.find(1, 2).sort, Project.new(:tracker_ids => [1, 2]).trackers.sort
                  end
                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.where(:id => 1).update_all(["identifier = ''"])
                  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_to_param_should_be_nil_for_new_records
                  project = Project.new
                  project.identifier = "foo"
                  assert_nil project.to_param
                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.where(:status => Project::STATUS_ARCHIVED).count" 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).count
                  # 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.where(:project_id => @ecookbook.id).first
                  assert_nil Board.where(:project_id => @ecookbook.id).first
                  assert_nil Issue.where(:project_id => @ecookbook.id).first
                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! :parent_issue_id => issues[1].id
                  issues[2].update! :parent_issue_id => issues[1].id
                  assert_equal 2, issues[1].children.count
                  assert_nothing_raised do
                    Project.find(1).destroy
                  end
                  assert_equal 0, Issue.where(:id => issues.map(&:id)).count
                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.where("project_id IS NOT NULL").count
                  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").count
                  assert_equal 0, Project.connection.select_all("SELECT * FROM custom_fields_projects").count
                  assert_equal 0, CustomValue.where(:customized_type => ['Project', 'Issue', 'TimeEntry', 'Version']).count
                end
                def test_destroy_should_delete_time_entries_custom_values
                  project = Project.generate!
                  time_entry = TimeEntry.generate!(:project => project, :custom_field_values => {10 => '1'})
                  assert_difference 'CustomValue.where(:customized_type => "TimeEntry").count', -1 do
                    assert project.destroy
                  end
                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.sort_by(&:name), parent.children.to_a
                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."
+                 assert_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_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
                test "#rolled_up_trackers should ignore projects with issue_tracking module disabled" do
                  parent = Project.generate!
                  parent.trackers = Tracker.find([1, 2])
                  child = Project.generate_with_parent!(parent)
                  child.trackers = Tracker.find([2, 3])
                  assert_equal [1, 2, 3], parent.rolled_up_trackers.collect(&:id).sort
                  assert child.disable_module!(:issue_tracking)
                  parent.reload
                  assert_equal [1, 2], parent.rolled_up_trackers.collect(&:id).sort
                end
                test "#rolled_up_versions should include the versions for the current project" do
                  project = Project.generate!
                  parent_version_1 = Version.generate!(:project => project)
                  parent_version_2 = Version.generate!(:project => project)
                  assert_equal [parent_version_1, parent_version_2].sort,
                    project.rolled_up_versions.sort
                end
                test "#rolled_up_versions should include versions for a subproject" do
                  project = Project.generate!
                  parent_version_1 = Version.generate!(:project => project)
                  parent_version_2 = Version.generate!(:project => project)
                  subproject = Project.generate_with_parent!(project)
                  subproject_version = Version.generate!(:project => subproject)
                  assert_equal [parent_version_1, parent_version_2, subproject_version].sort,
                    project.rolled_up_versions.sort
                end
                test "#rolled_up_versions should include versions for a sub-subproject" do
                  project = Project.generate!
                  parent_version_1 = Version.generate!(:project => project)
                  parent_version_2 = Version.generate!(:project => project)
                  subproject = Project.generate_with_parent!(project)
                  sub_subproject = Project.generate_with_parent!(subproject)
                  sub_subproject_version = Version.generate!(:project => sub_subproject)
                  project.reload
                  assert_equal [parent_version_1, parent_version_2, sub_subproject_version].sort,
                    project.rolled_up_versions.sort
                end
                test "#rolled_up_versions should only check active projects" do
                  project = Project.generate!
                  parent_version_1 = Version.generate!(:project => project)
                  parent_version_2 = Version.generate!(:project => project)
                  subproject = Project.generate_with_parent!(project)
                  subproject_version = Version.generate!(:project => subproject)
                  assert subproject.archive
                  project.reload
                  assert !subproject.active?
                  assert_equal [parent_version_1, parent_version_2].sort,
                    project.rolled_up_versions.sort
                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.where(: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
                def test_enabled_modules_names_with_nil_should_clear_modules
                  p = Project.find(1)
                  p.enabled_module_names = nil
                  assert_equal [], p.enabled_modules
                end
                test "enabled_modules should define module by names and preserve ids" do
                  @project = Project.find(1)
                  # Remove one module
                  modules = @project.enabled_modules.to_a.slice(0..-2)
                  assert modules.any?
                  assert_difference 'EnabledModule.count', -1 do
                    @project.enabled_module_names = modules.collect(&:name)
                  end
                  @project.reload
                  # Ids should be preserved
                  assert_equal @project.enabled_module_ids.sort, modules.collect(&:id).sort
                end
                test "enabled_modules should enable a module" do
                  @project = Project.find(1)
                  @project.enabled_module_names = []
                  @project.reload
                  assert_equal [], @project.enabled_module_names
                  #with string
                  @project.enable_module!("issue_tracking")
                  assert_equal ["issue_tracking"], @project.enabled_module_names
                  #with symbol
                  @project.enable_module!(:gantt)
                  assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
                  #don't add a module twice
                  @project.enable_module!("issue_tracking")
                  assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
                end
                test "enabled_modules should disable a module" do
                  @project = Project.find(1)
                  #with string
                  assert @project.enabled_module_names.include?("issue_tracking")
                  @project.disable_module!("issue_tracking")
                  assert ! @project.reload.enabled_module_names.include?("issue_tracking")
                  #with symbol
                  assert @project.enabled_module_names.include?("gantt")
                  @project.disable_module!(:gantt)
                  assert ! @project.reload.enabled_module_names.include?("gantt")
                  #with EnabledModule object
                  first_module = @project.enabled_modules.first
                  @project.disable_module!(first_module)
                  assert ! @project.reload.enabled_module_names.include?(first_module.name)
                end
                def test_enabled_module_names_should_not_recreate_enabled_modules
                  project = Project.find(1)
                  # Remove one module
                  modules = project.enabled_modules.to_a.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.trackers, copied_project.trackers
                  # Default attributes
                  assert_equal 1, copied_project.status
                end
                def test_copy_from_should_copy_enabled_modules
                  source = Project.generate!
                  source.enabled_module_names = %w(issue_tracking wiki)
                  copy = Project.copy_from(source)
                  copy.name = 'Copy'
                  copy.identifier = 'copy'
                  assert_difference 'EnabledModule.count', 2 do
                    copy.save!
                  end
                  assert_equal 2, copy.reload.enabled_modules.count
                  assert_equal 2, source.reload.enabled_modules.count
                end
                def test_activities_should_use_the_system_activities
                  project = Project.find(1)
                  assert_equal project.activities.to_a, TimeEntryActivity.where(:active => true).to_a
                  assert_kind_of ActiveRecord::Relation, project.activities
                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"
                  assert_kind_of ActiveRecord::Relation, project.activities
                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
                test "#start_date should be nil if there are no issues on the project" do
                  project = Project.generate!
                  assert_nil project.start_date
                end
                test "#start_date should be nil when issues have no start date" do
                  project = Project.generate!
                  project.trackers << Tracker.generate!
                  early = 7.days.ago.to_date
                  Issue.generate!(:project => project, :start_date => nil)
                  assert_nil project.start_date
                end
                test "#start_date should be the earliest start date of it's issues" do
                  project = Project.generate!
                  project.trackers << Tracker.generate!
                  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
                test "#due_date should be nil if there are no issues on the project" do
                  project = Project.generate!
                  assert_nil project.due_date
                end
                test "#due_date should be nil if there are no issues with due dates" do
                  project = Project.generate!
                  project.trackers << Tracker.generate!
                  Issue.generate!(:project => project, :due_date => nil)
                  assert_nil project.due_date
                end
                test "#due_date should be the latest due date of it's issues" do
                  project = Project.generate!
                  project.trackers << Tracker.generate!
                  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
                test "#due_date should be the latest due date of it's versions" do
                  project = Project.generate!
                  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
                test "#due_date should pick the latest date from it's issues and versions" do
                  project = Project.generate!
                  project.trackers << Tracker.generate!
                  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
                test "#completed_percent with no versions should be 100" do
                  project = Project.generate!
                  assert_equal 100, project.completed_percent
                end
                test "#completed_percent with versions should return 0 if the versions have no issues" do
                  project = Project.generate!
                  Version.generate!(:project => project)
                  Version.generate!(:project => project)
                  assert_equal 0, project.completed_percent
                end
                test "#completed_percent with versions should return 100 if the version has only closed issues" do
                  project = Project.generate!
                  project.trackers << Tracker.generate!
                  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
                test "#completed_percent with versions should return the averaged completed percent of the versions (not weighted)" do
                  project = Project.generate!
                  project.trackers << Tracker.generate!
                  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
                test "#notified_users" 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)
                  assert project.notified_users.include?(user_with_membership_notification), "should include members with a mail notification"
                  assert project.notified_users.include?(all_events_user), "should include users with the 'all' notification option"
                  assert !project.notified_users.include?(no_events_user), "should not include users with the 'none' notification option"
                  assert !project.notified_users.include?(only_my_events_user), "should not include users with the 'only_my_events' notification option"
                  assert !project.notified_users.include?(only_assigned_user), "should not include users with the 'only_assigned' notification option"
                  assert !project.notified_users.include?(only_owned_user), "should not include users with the 'only_owner' notification option"
                end
                def test_override_roles_without_builtin_group_memberships
                  project = Project.generate!
                  assert_equal [Role.anonymous], project.override_roles(Role.anonymous)
                  assert_equal [Role.non_member], project.override_roles(Role.non_member)
                end
                def test_css_classes
                  p = Project.new
                  assert_kind_of String, p.css_classes
                  assert_not_include 'archived', p.css_classes.split
                  assert_not_include 'closed', p.css_classes.split
                end
                def test_css_classes_for_archived_project
                  p = Project.new
                  p.status = Project::STATUS_ARCHIVED
                  assert_include 'archived', p.css_classes.split
                end
                def test_css_classes_for_closed_project
                  p = Project.new
                  p.status = Project::STATUS_CLOSED
                  assert_include 'closed', p.css_classes.split
                end
                def test_combination_of_visible_and_distinct_scopes_in_case_anonymous_group_has_memberships_should_not_error
                  project = Project.find(1)
                  member = Member.create!(:project => project, :principal => Group.anonymous, :roles => [Role.generate!])
                  project.members << member
                  assert_nothing_raised do
                    Project.distinct.visible.to_a
                  end
                end
              end

test/unit/repository_git_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 RepositoryGitTest < ActiveSupport::TestCase
                fixtures :projects, :repositories, :enabled_modules, :users, :roles
                include Redmine::I18n
                REPOSITORY_PATH = Rails.root.join('tmp/test/git_repository').to_s
                REPOSITORY_PATH.gsub!(/\//, "\\") if Redmine::Platform.mswin?
                NUM_REV = 28
                NUM_HEAD = 6
                FELIX_HEX  = "Felix Sch\xC3\xA4fer".force_encoding('UTF-8')
                CHAR_1_HEX = "\xc3\x9c".force_encoding('UTF-8')
                ## Git, Mercurial and CVS path encodings are binary.
                ## Subversion supports URL encoding for path.
                ## Redmine Mercurial adapter and extension use URL encoding.
                ## Git accepts only binary path in command line parameter.
                ## So, there is no way to use binary command line parameter in JRuby.
                JRUBY_SKIP     = (RUBY_PLATFORM == 'java')
                JRUBY_SKIP_STR = "TODO: This test fails in JRuby"
                def setup
                  @project = Project.find(3)
                  @repository = Repository::Git.create(
                                      :project       => @project,
                                      :url           => REPOSITORY_PATH,
                                      :path_encoding => 'ISO-8859-1'
                                      )
                  assert @repository
                end
                def test_nondefault_repo_with_blank_identifier_destruction
                  Repository.delete_all
                  repo1 = Repository::Git.new(
                                        :project    => @project,
                                        :url        => REPOSITORY_PATH,
                                        :identifier => '',
                                        :is_default => true
                                      )
                  assert repo1.save
                  repo1.fetch_changesets
                  repo2 = Repository::Git.new(
                                        :project    => @project,
                                        :url        => REPOSITORY_PATH,
                                        :identifier => 'repo2',
                                        :is_default => true
                                  )
                  assert repo2.save
                  repo2.fetch_changesets
                  repo1.reload
                  repo2.reload
                  assert !repo1.is_default?
                  assert  repo2.is_default?
                  assert_difference 'Repository.count', -1 do
                    repo1.destroy
                  end
                end
                def test_blank_path_to_repository_error_message
                  set_language_if_valid 'en'
                  repo = Repository::Git.new(
                                        :project      => @project,
                                        :identifier   => 'test'
                                      )
                  assert !repo.save
                  assert_include "Path to repository cannot be blank",
                                 repo.errors.full_messages
                end
                def test_blank_path_to_repository_error_message_fr
                  set_language_if_valid 'fr'
                  str = "Chemin du d\xc3\xa9p\xc3\xb4t doit \xc3\xaatre renseign\xc3\xa9(e)".force_encoding('UTF-8')
                  repo = Repository::Git.new(
                                        :project      => @project,
                                        :url          => "",
                                        :identifier   => 'test',
                                        :path_encoding => ''
                                      )
                  assert !repo.save
                  assert_include str, repo.errors.full_messages
                end
                if File.directory?(REPOSITORY_PATH)
                  ## Ruby uses ANSI api to fork a process on Windows.
                  ## Japanese Shift_JIS and Traditional Chinese Big5 have 0x5c(backslash) problem
                  ## and these are incompatible with ASCII.
                  ## Git for Windows (msysGit) changed internal API from ANSI to Unicode in 1.7.10
                  ## http://code.google.com/p/msysgit/issues/detail?id=80
                  ## So, Latin-1 path tests fail on Japanese Windows
                  WINDOWS_PASS = (Redmine::Platform.mswin? &&
                                       Redmine::Scm::Adapters::GitAdapter.client_version_above?([1, 7, 10]))
                  WINDOWS_SKIP_STR = "TODO: This test fails in Git for Windows above 1.7.10"
                  def test_scm_available
                    klass = Repository::Git
                    assert_equal "Git", klass.scm_name
                    assert klass.scm_adapter_class
                    assert_not_equal "", klass.scm_command
                    assert_equal true, klass.scm_available
                  end
                  def test_entries
                    entries = @repository.entries
                    assert_kind_of Redmine::Scm::Adapters::Entries, entries
                  end
                  def test_fetch_changesets_from_scratch
                    assert_nil @repository.extra_info
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_equal 39, @repository.filechanges.count
                    commit = @repository.changesets.find_by_revision("7234cb2750b63f47bff735edc50a1c0a433c2518")
                    assert_equal "7234cb2750b63f47bff735edc50a1c0a433c2518", commit.scmid
                    assert_equal "Initial import.\nThe repository contains 3 files.", commit.comments
                    assert_equal "jsmith <jsmith@foo.bar>", commit.committer
                    assert_equal User.find_by_login('jsmith'), commit.user
                    # TODO: add a commit with commit time <> author time to the test repository
                    assert_equal Time.gm(2007, 12, 14, 9, 22, 52), commit.committed_on
                    assert_equal "2007-12-14".to_date, commit.commit_date
                    assert_equal 3, commit.filechanges.count
                    change = commit.filechanges.sort_by(&:path).first
                    assert_equal "README", change.path
-                   assert_equal nil, change.from_path
+                   assert_nil change.from_path
                    assert_equal "A", change.action
                    assert_equal NUM_HEAD, @repository.extra_info["heads"].size
                  end
                  def test_fetch_changesets_incremental
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    extra_info_heads = @repository.extra_info["heads"].dup
                    assert_equal NUM_HEAD, extra_info_heads.size
                    extra_info_heads.delete_if { |x| x == "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c" }
                    assert_equal 4, extra_info_heads.size
                    del_revs = [
                        "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c",
                        "ed5bb786bbda2dee66a2d50faf51429dbc043a7b",
                        "4f26664364207fa8b1af9f8722647ab2d4ac5d43",
                        "deff712f05a90d96edbd70facc47d944be5897e3",
                        "32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf",
                        "7e61ac704deecde634b51e59daa8110435dcb3da",
                       ]
                    @repository.changesets.each do |rev|
                      rev.destroy if del_revs.detect {|r| r == rev.scmid.to_s }
                    end
                    @project.reload
                    cs1 = @repository.changesets
                    assert_equal NUM_REV - 6, cs1.count
                    extra_info_heads << "4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8"
                    h = {}
                    h["heads"] = extra_info_heads
                    @repository.merge_extra_info(h)
                    @repository.save
                    @project.reload
                    assert @repository.extra_info["heads"].index("4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8")
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_equal NUM_HEAD, @repository.extra_info["heads"].size
                    assert @repository.extra_info["heads"].index("83ca5fd546063a3c7dc2e568ba3355661a9e2b2c")
                  end
                  def test_fetch_changesets_history_editing
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    extra_info_heads = @repository.extra_info["heads"].dup
                    assert_equal NUM_HEAD, extra_info_heads.size
                    extra_info_heads.delete_if { |x| x == "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c" }
                    assert_equal 4, extra_info_heads.size
                    del_revs = [
                        "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c",
                        "ed5bb786bbda2dee66a2d50faf51429dbc043a7b",
                        "4f26664364207fa8b1af9f8722647ab2d4ac5d43",
                        "deff712f05a90d96edbd70facc47d944be5897e3",
                        "32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf",
                        "7e61ac704deecde634b51e59daa8110435dcb3da",
                       ]
                    @repository.changesets.each do |rev|
                      rev.destroy if del_revs.detect {|r| r == rev.scmid.to_s }
                    end
                    @project.reload
                    assert_equal NUM_REV - 6, @repository.changesets.count
                    c = Changeset.new(:repository   => @repository,
                                      :committed_on => Time.now,
                                      :revision     => "abcd1234efgh",
                                      :scmid        => "abcd1234efgh",
                                      :comments     => 'test')
                    assert c.save
                    @project.reload
                    assert_equal NUM_REV - 5, @repository.changesets.count
                    extra_info_heads << "1234abcd5678"
                    h = {}
                    h["heads"] = extra_info_heads
                    @repository.merge_extra_info(h)
                    @repository.save
                    @project.reload
                    h1 = @repository.extra_info["heads"].dup
                    assert h1.index("1234abcd5678")
                    assert_equal 5, h1.size
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV - 5, @repository.changesets.count
                    h2 = @repository.extra_info["heads"].dup
                    assert_equal h1, h2
                  end
                  def test_clear_changesets_should_keep_report_last_commit
                    assert_nil @repository.extra_info
                    @repository.report_last_commit = "1"
                    @repository.save
                    @repository.send(:clear_changesets)
                    assert_equal true, @repository.report_last_commit
                  end
                  def test_refetch_after_clear_changesets
                    assert_nil @repository.extra_info
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    @repository.send(:clear_changesets)
                    @project.reload
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                  end
                  def test_parents
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    r1 = @repository.find_changeset_by_name("7234cb2750b63")
                    assert_equal [], r1.parents
                    r2 = @repository.find_changeset_by_name("899a15dba03a3")
                    assert_equal 1, r2.parents.length
                    assert_equal "7234cb2750b63f47bff735edc50a1c0a433c2518",
                                 r2.parents[0].identifier
                    r3 = @repository.find_changeset_by_name("32ae898b720c2")
                    assert_equal 2, r3.parents.length
                    r4 = [r3.parents[0].identifier, r3.parents[1].identifier].sort
                    assert_equal "4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8", r4[0]
                    assert_equal "7e61ac704deecde634b51e59daa8110435dcb3da", r4[1]
                  end
                  def test_db_consistent_ordering_init
                    assert_nil @repository.extra_info
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal 1, @repository.extra_info["db_consistent"]["ordering"]
                  end
                  def test_db_consistent_ordering_before_1_2
                    assert_nil @repository.extra_info
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_not_nil @repository.extra_info
                    h = {}
                    h["heads"] = []
                    h["branches"] = {}
                    h["db_consistent"] = {}
                    @repository.merge_extra_info(h)
                    @repository.save
                    assert_equal NUM_REV, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal 0, @repository.extra_info["db_consistent"]["ordering"]
                    extra_info_heads = @repository.extra_info["heads"].dup
                    extra_info_heads.delete_if { |x| x == "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c" }
                    del_revs = [
                        "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c",
                        "ed5bb786bbda2dee66a2d50faf51429dbc043a7b",
                        "4f26664364207fa8b1af9f8722647ab2d4ac5d43",
                        "deff712f05a90d96edbd70facc47d944be5897e3",
                        "32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf",
                        "7e61ac704deecde634b51e59daa8110435dcb3da",
                       ]
                    @repository.changesets.each do |rev|
                      rev.destroy if del_revs.detect {|r| r == rev.scmid.to_s }
                    end
                    @project.reload
                    cs1 = @repository.changesets
                    assert_equal NUM_REV - 6, cs1.count
                    assert_equal 0, @repository.extra_info["db_consistent"]["ordering"]
                    extra_info_heads << "4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8"
                    h = {}
                    h["heads"] = extra_info_heads
                    @repository.merge_extra_info(h)
                    @repository.save
                    @project.reload
                    assert @repository.extra_info["heads"].index("4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8")
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_equal NUM_HEAD, @repository.extra_info["heads"].size
                    assert_equal 0, @repository.extra_info["db_consistent"]["ordering"]
                  end
                  def test_heads_from_branches_hash
                    assert_nil @repository.extra_info
                    assert_equal 0, @repository.changesets.count
                    assert_equal [], @repository.heads_from_branches_hash
                    h = {}
                    h["branches"] = {}
                    h["branches"]["test1"] = {}
                    h["branches"]["test1"]["last_scmid"] = "1234abcd"
                    h["branches"]["test2"] = {}
                    h["branches"]["test2"]["last_scmid"] = "abcd1234"
                    @repository.merge_extra_info(h)
                    @repository.save
                    @project.reload
                    assert_equal ["1234abcd", "abcd1234"], @repository.heads_from_branches_hash.sort
                  end
                  def test_latest_changesets
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    # with limit
                    changesets = @repository.latest_changesets('', 'master', 2)
                    assert_equal 2, changesets.size
                    # with path
                    changesets = @repository.latest_changesets('images', 'master')
                    assert_equal [
                            'deff712f05a90d96edbd70facc47d944be5897e3',
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', nil)
                    assert_equal [
                            '32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf',
                            '4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8',
                            '713f4944648826f558cf548222f813dabe7cbb04',
                            '61b685fbe55ab05b5ac68402d5720c1a6ac973d1',
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    # with path, revision and limit
                    changesets = @repository.latest_changesets('images', '899a15dba')
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('images', '899a15dba', 1)
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', '899a15dba')
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', '899a15dba', 1)
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                        ], changesets.collect(&:revision)
                    # with path, tag and limit
                    changesets = @repository.latest_changesets('images', 'tag01.annotated')
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('images', 'tag01.annotated', 1)
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', 'tag01.annotated')
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', 'tag01.annotated', 1)
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                        ], changesets.collect(&:revision)
                    # with path, branch and limit
                    changesets = @repository.latest_changesets('images', 'test_branch')
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('images', 'test_branch', 1)
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', 'test_branch')
                    assert_equal [
                            '713f4944648826f558cf548222f813dabe7cbb04',
                            '61b685fbe55ab05b5ac68402d5720c1a6ac973d1',
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', 'test_branch', 2)
                    assert_equal [
                            '713f4944648826f558cf548222f813dabe7cbb04',
                            '61b685fbe55ab05b5ac68402d5720c1a6ac973d1',
                        ], changesets.collect(&:revision)
                    if WINDOWS_PASS
                      puts WINDOWS_SKIP_STR
                    elsif JRUBY_SKIP
                      puts JRUBY_SKIP_STR
                    else
                      # latin-1 encoding path
                      changesets = @repository.latest_changesets(
                                    "latin-1-dir/test-#{CHAR_1_HEX}-2.txt", '64f1f3e89')
                      assert_equal [
                            '64f1f3e89ad1cb57976ff0ad99a107012ba3481d',
                            '4fc55c43bf3d3dc2efb66145365ddc17639ce81e',
                        ], changesets.collect(&:revision)
                      changesets = @repository.latest_changesets(
                                  "latin-1-dir/test-#{CHAR_1_HEX}-2.txt", '64f1f3e89', 1)
                      assert_equal [
                            '64f1f3e89ad1cb57976ff0ad99a107012ba3481d',
                        ], changesets.collect(&:revision)
                    end
                  end
                  def test_latest_changesets_latin_1_dir
                    if WINDOWS_PASS
                      puts WINDOWS_SKIP_STR
                    elsif JRUBY_SKIP
                      puts JRUBY_SKIP_STR
                    else
                      assert_equal 0, @repository.changesets.count
                      @repository.fetch_changesets
                      @project.reload
                      assert_equal NUM_REV, @repository.changesets.count
                      changesets = @repository.latest_changesets(
                                  "latin-1-dir/test-#{CHAR_1_HEX}-subdir", '1ca7f5ed')
                      assert_equal [
                            '1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127',
                        ], changesets.collect(&:revision)
                    end
                  end
                  def test_find_changeset_by_name
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['7234cb2750b63f47bff735edc50a1c0a433c2518', '7234cb2750b'].each do |r|
                      assert_equal '7234cb2750b63f47bff735edc50a1c0a433c2518',
                                   @repository.find_changeset_by_name(r).revision
                    end
                  end
                  def test_find_changeset_by_empty_name
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['', ' ', nil].each do |r|
                      assert_nil @repository.find_changeset_by_name(r)
                    end
                  end
                  def test_identifier
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    c = @repository.changesets.find_by_revision(
                                        '7234cb2750b63f47bff735edc50a1c0a433c2518')
                    assert_equal c.scmid, c.identifier
                  end
                  def test_format_identifier
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    c = @repository.changesets.find_by_revision(
                                        '7234cb2750b63f47bff735edc50a1c0a433c2518')
                    assert_equal '7234cb27', c.format_identifier
                  end
                  def test_activities
                    c = Changeset.new(:repository => @repository,
                                      :committed_on => Time.now,
                                      :revision => 'abc7234cb2750b63f47bff735edc50a1c0a433c2',
                                      :scmid    => 'abc7234cb2750b63f47bff735edc50a1c0a433c2',
                                      :comments => 'test')
                    assert c.event_title.include?('abc7234c:')
                    assert_equal 'abc7234cb2750b63f47bff735edc50a1c0a433c2', c.event_url[:rev]
                  end
                  def test_log_utf8
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    c = @repository.changesets.find_by_revision(
                                      'ed5bb786bbda2dee66a2d50faf51429dbc043a7b')
                    assert_equal "#{FELIX_HEX} <felix@fachschaften.org>", c.committer
                  end
                  def test_previous
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    %w|1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127 1ca7f5ed|.each do |r1|
                      changeset = @repository.find_changeset_by_name(r1)
                      %w|64f1f3e89ad1cb57976ff0ad99a107012ba3481d 64f1f3e89ad1|.each do |r2|
                        assert_equal @repository.find_changeset_by_name(r2), changeset.previous
                      end
                    end
                  end
                  def test_previous_nil
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    %w|7234cb2750b63f47bff735edc50a1c0a433c2518 7234cb275|.each do |r1|
                      changeset = @repository.find_changeset_by_name(r1)
                      assert_nil changeset.previous
                    end
                  end
                  def test_next
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    %w|64f1f3e89ad1cb57976ff0ad99a107012ba3481d 64f1f3e89ad1|.each do |r2|
                      changeset = @repository.find_changeset_by_name(r2)
                      %w|1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127 1ca7f5ed|.each do |r1|
                      assert_equal @repository.find_changeset_by_name(r1), changeset.next
                      end
                    end
                  end
                  def test_next_nil
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    %w|2a682156a3b6e77a8bf9cd4590e8db757f3c6c78 2a682156a3b6e77a|.each do |r1|
                      changeset = @repository.find_changeset_by_name(r1)
                      assert_nil changeset.next
                    end
                  end
                else
                  puts "Git test repository NOT FOUND. Skipping unit tests !!!"
                  def test_fake; assert true end
                end
              end

test/unit/user_test.rb +3 -3

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 UserTest < ActiveSupport::TestCase
                fixtures :users, :email_addresses, :members, :projects, :roles, :member_roles, :auth_sources,
                          :trackers, :issue_statuses,
                          :projects_trackers,
                          :watchers,
                          :issue_categories, :enumerations, :issues,
                          :journals, :journal_details,
                          :groups_users,
                          :enabled_modules,
                          :tokens
                include Redmine::I18n
                def setup
                  @admin = User.find(1)
                  @jsmith = User.find(2)
                  @dlopper = User.find(3)
                end
                def test_sorted_scope_should_sort_user_by_display_name
                  # Use .active to ignore anonymous with localized display name
                  assert_equal User.active.map(&:name).map(&:downcase).sort,
                               User.active.sorted.map(&:name).map(&:downcase)
                end
                def test_generate
                  User.generate!(:firstname => 'Testing connection')
                  User.generate!(:firstname => 'Testing connection')
                  assert_equal 2, User.where(:firstname => 'Testing connection').count
                end
                def test_truth
                  assert_kind_of User, @jsmith
                end
                def test_should_validate_status
                  user = User.new
                  user.status = 0
                  assert !user.save
                  assert_include I18n.translate('activerecord.errors.messages.invalid'), user.errors[:status]
                end
                def test_mail_should_be_stripped
                  u = User.new
                  u.mail = " foo@bar.com  "
                  assert_equal "foo@bar.com", u.mail
                end
                def test_should_create_email_address
                  u = User.new(:firstname => "new", :lastname => "user")
                  u.login = "create_email_address"
                  u.mail = "defaultemail@somenet.foo"
                  assert u.save
                  u.reload
                  assert u.email_address
                  assert_equal "defaultemail@somenet.foo", u.email_address.address
                  assert_equal true, u.email_address.is_default
                  assert_equal true, u.email_address.notify
                end
                def test_should_not_create_user_without_mail
                  set_language_if_valid 'en'
                  u = User.new(:firstname => "new", :lastname => "user")
                  u.login = "user_without_mail"
                  assert !u.save
                  assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
                end
                def test_should_not_create_user_with_blank_mail
                  set_language_if_valid 'en'
                  u = User.new(:firstname => "new", :lastname => "user")
                  u.login = "user_with_blank_mail"
                  u.mail = ''
                  assert !u.save
                  assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
                end
                def test_should_not_update_user_with_blank_mail
                  set_language_if_valid 'en'
                  u = User.find(2)
                  u.mail = ''
                  assert !u.save
                  assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
                end
                def test_login_length_validation
                  user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  user.login = "x" * (User::LOGIN_LENGTH_LIMIT+1)
                  assert !user.valid?
                  user.login = "x" * (User::LOGIN_LENGTH_LIMIT)
                  assert user.valid?
                  assert user.save
                end
                def test_generate_password_should_respect_minimum_password_length
                  with_settings :password_min_length => 15 do
                    user = User.generate!(:generate_password => true)
                    assert user.password.length >= 15
                  end
                end
                def test_generate_password_should_not_generate_password_with_less_than_10_characters
                  with_settings :password_min_length => 4 do
                    user = User.generate!(:generate_password => true)
                    assert user.password.length >= 10
                  end
                end
                def test_generate_password_on_create_should_set_password
                  user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  user.login = "newuser"
                  user.generate_password = true
                  assert user.save
                  password = user.password
                  assert user.check_password?(password)
                end
                def test_generate_password_on_update_should_update_password
                  user = User.find(2)
                  hash = user.hashed_password
                  user.generate_password = true
                  assert user.save
                  password = user.password
                  assert user.check_password?(password)
                  assert_not_equal hash, user.reload.hashed_password
                end
                def test_create
                  user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  user.login = "jsmith"
                  user.password, user.password_confirmation = "password", "password"
                  # login uniqueness
                  assert !user.save
                  assert_equal 1, user.errors.count
                  user.login = "newuser"
                  user.password, user.password_confirmation = "password", "pass"
                  # password confirmation
                  assert !user.save
                  assert_equal 1, user.errors.count
                  user.password, user.password_confirmation = "password", "password"
                  assert user.save
                end
                def test_user_before_create_should_set_the_mail_notification_to_the_default_setting
                  @user1 = User.generate!
                  assert_equal 'only_my_events', @user1.mail_notification
                  with_settings :default_notification_option => 'all' do
                    @user2 = User.generate!
                    assert_equal 'all', @user2.mail_notification
                  end
                end
                def test_user_login_should_be_case_insensitive
                  u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  u.login = 'newuser'
                  u.password, u.password_confirmation = "password", "password"
                  assert u.save
                  u = User.new(:firstname => "Similar", :lastname => "User",
                               :mail => "similaruser@somenet.foo")
                  u.login = 'NewUser'
                  u.password, u.password_confirmation = "password", "password"
                  assert !u.save
                  assert_include I18n.translate('activerecord.errors.messages.taken'), u.errors[:login]
                end
                def test_mail_uniqueness_should_not_be_case_sensitive
                  set_language_if_valid 'en'
                  u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  u.login = 'newuser1'
                  u.password, u.password_confirmation = "password", "password"
                  assert u.save
                  u = User.new(:firstname => "new", :lastname => "user", :mail => "newUser@Somenet.foo")
                  u.login = 'newuser2'
                  u.password, u.password_confirmation = "password", "password"
                  assert !u.save
                  assert_include "Email #{I18n.translate('activerecord.errors.messages.taken')}", u.errors.full_messages
                end
                def test_update
                  assert_equal "admin", @admin.login
                  @admin.login = "john"
                  assert @admin.save, @admin.errors.full_messages.join("; ")
                  @admin.reload
                  assert_equal "john", @admin.login
                end
                def test_update_should_not_fail_for_legacy_user_with_different_case_logins
                  u1 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser1@somenet.foo")
                  u1.login = 'newuser1'
                  assert u1.save
                  u2 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser2@somenet.foo")
                  u2.login = 'newuser1'
                  assert u2.save(:validate => false)
                  user = User.find(u2.id)
                  user.firstname = "firstname"
                  assert user.save, "Save failed"
                end
                def test_destroy_should_delete_members_and_roles
                  members = Member.where(:user_id => 2)
                  ms = members.count
                  rs = members.collect(&:roles).flatten.size
                  assert ms > 0
                  assert rs > 0
                  assert_difference 'Member.count', - ms do
                    assert_difference 'MemberRole.count', - rs do
                      User.find(2).destroy
                    end
                  end
                  assert_nil User.find_by_id(2)
                  assert_equal 0, Member.where(:user_id => 2).count
                end
                def test_destroy_should_update_attachments
                  attachment = Attachment.create!(:container => Project.find(1),
                    :file => uploaded_test_file("testfile.txt", "text/plain"),
                    :author_id => 2)
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, attachment.reload.author
                end
                def test_destroy_should_update_comments
                  comment = Comment.create!(
                    :commented => News.create!(:project_id => 1,
                                               :author_id => 1, :title => 'foo', :description => 'foo'),
                    :author => User.find(2),
                    :comments => 'foo'
                  )
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, comment.reload.author
                end
                def test_destroy_should_update_issues
                  issue = Issue.create!(:project_id => 1, :author_id => 2,
                                        :tracker_id => 1, :subject => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, issue.reload.author
                end
                def test_destroy_should_unassign_issues
                  issue = Issue.create!(:project_id => 1, :author_id => 1,
                                        :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil issue.reload.assigned_to
                end
                def test_destroy_should_update_journals
                  issue = Issue.create!(:project_id => 1, :author_id => 2,
                                        :tracker_id => 1, :subject => 'foo')
                  issue.init_journal(User.find(2), "update")
                  issue.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, issue.journals.first.reload.user
                end
                def test_destroy_should_update_journal_details_old_value
                  issue = Issue.create!(:project_id => 1, :author_id => 1,
                                        :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
                  issue.init_journal(User.find(1), "update")
                  issue.assigned_to_id = nil
                  assert_difference 'JournalDetail.count' do
                    issue.save!
                  end
                  journal_detail = JournalDetail.order('id DESC').first
                  assert_equal '2', journal_detail.old_value
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous.id.to_s, journal_detail.reload.old_value
                end
                def test_destroy_should_update_journal_details_value
                  issue = Issue.create!(:project_id => 1, :author_id => 1,
                                        :tracker_id => 1, :subject => 'foo')
                  issue.init_journal(User.find(1), "update")
                  issue.assigned_to_id = 2
                  assert_difference 'JournalDetail.count' do
                    issue.save!
                  end
                  journal_detail = JournalDetail.order('id DESC').first
                  assert_equal '2', journal_detail.value
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous.id.to_s, journal_detail.reload.value
                end
                def test_destroy_should_update_messages
                  board = Board.create!(:project_id => 1, :name => 'Board', :description => 'Board')
                  message = Message.create!(:board_id => board.id, :author_id => 2,
                                            :subject => 'foo', :content => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, message.reload.author
                end
                def test_destroy_should_update_news
                  news = News.create!(:project_id => 1, :author_id => 2,
                                      :title => 'foo', :description => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, news.reload.author
                end
                def test_destroy_should_delete_private_queries
                  query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PRIVATE)
                  query.project_id = 1
                  query.user_id = 2
                  query.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil Query.find_by_id(query.id)
                end
                def test_destroy_should_update_public_queries
                  query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PUBLIC)
                  query.project_id = 1
                  query.user_id = 2
                  query.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, query.reload.user
                end
                def test_destroy_should_update_time_entries
                  entry = TimeEntry.new(:hours => '2', :spent_on => Date.today,
                                        :activity => TimeEntryActivity.create!(:name => 'foo'))
                  entry.project_id = 1
                  entry.user_id = 2
                  entry.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, entry.reload.user
                end
                def test_destroy_should_delete_tokens
                  token = Token.create!(:user_id => 2, :value => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil Token.find_by_id(token.id)
                end
                def test_destroy_should_delete_watchers
                  issue = Issue.create!(:project_id => 1, :author_id => 1,
                                        :tracker_id => 1, :subject => 'foo')
                  watcher = Watcher.create!(:user_id => 2, :watchable => issue)
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil Watcher.find_by_id(watcher.id)
                end
                def test_destroy_should_update_wiki_contents
                  wiki_content = WikiContent.create!(
                    :text => 'foo',
                    :author_id => 2,
                    :page => WikiPage.create!(:title => 'Foo',
                                              :wiki => Wiki.create!(:project_id => 3,
                                                                    :start_page => 'Start'))
                  )
                  wiki_content.text = 'bar'
                  assert_difference 'WikiContent::Version.count' do
                    wiki_content.save!
                  end
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, wiki_content.reload.author
                  wiki_content.versions.each do |version|
                    assert_equal User.anonymous, version.reload.author
                  end
                end
                def test_destroy_should_nullify_issue_categories
                  category = IssueCategory.create!(:project_id => 1, :assigned_to_id => 2, :name => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil category.reload.assigned_to_id
                end
                def test_destroy_should_nullify_changesets
                  changeset = Changeset.create!(
                    :repository => Repository::Subversion.create!(
                      :project_id => 1,
                      :url => 'file:///tmp',
                      :identifier => 'tmp'
                    ),
                    :revision => '12',
                    :committed_on => Time.now,
                    :committer => 'jsmith'
                    )
                  assert_equal 2, changeset.user_id
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil changeset.reload.user_id
                end
                def test_anonymous_user_should_not_be_destroyable
                  assert_no_difference 'User.count' do
                    assert_equal false, User.anonymous.destroy
                  end
                end
                def test_password_change_should_destroy_tokens
                  recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
                  autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
                  user = User.find(2)
                  user.password, user.password_confirmation = "a new password", "a new password"
                  assert user.save
                  assert_nil Token.find_by_id(recovery_token.id)
                  assert_nil Token.find_by_id(autologin_token.id)
                end
                def test_mail_change_should_destroy_tokens
                  recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
                  autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
                  user = User.find(2)
                  user.mail = "user@somwehere.com"
                  assert user.save
                  assert_nil Token.find_by_id(recovery_token.id)
                  assert_equal autologin_token, Token.find_by_id(autologin_token.id)
                end
                def test_change_on_other_fields_should_not_destroy_tokens
                  recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
                  autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
                  user = User.find(2)
                  user.firstname = "Bobby"
                  assert user.save
                  assert_equal recovery_token, Token.find_by_id(recovery_token.id)
                  assert_equal autologin_token, Token.find_by_id(autologin_token.id)
                end
                def test_validate_login_presence
                  @admin.login = ""
                  assert !@admin.save
                  assert_equal 1, @admin.errors.count
                end
                def test_validate_mail_notification_inclusion
                  u = User.new
                  u.mail_notification = 'foo'
                  u.save
                  assert_not_equal [], u.errors[:mail_notification]
                end
                def test_password
                  user = User.try_to_login("admin", "admin")
                  assert_kind_of User, user
                  assert_equal "admin", user.login
                  user.password = "hello123"
                  assert user.save
                  user = User.try_to_login("admin", "hello123")
                  assert_kind_of User, user
                  assert_equal "admin", user.login
                end
                def test_validate_password_length
                  with_settings :password_min_length => '100' do
                    user = User.new(:firstname => "new100",
                                    :lastname => "user100", :mail => "newuser100@somenet.foo")
                    user.login = "newuser100"
                    user.password, user.password_confirmation = "password100", "password100"
                    assert !user.save
                    assert_equal 1, user.errors.count
                  end
                end
                def test_name_format
                  assert_equal 'John S.', @jsmith.name(:firstname_lastinitial)
                  assert_equal 'Smith, John', @jsmith.name(:lastname_comma_firstname)
                  assert_equal 'J. Smith', @jsmith.name(:firstinitial_lastname)
                  assert_equal 'J.-P. Lang', User.new(:firstname => 'Jean-Philippe', :lastname => 'Lang').name(:firstinitial_lastname)
                end
                def test_name_should_use_setting_as_default_format
                  with_settings :user_format => :firstname_lastname do
                    assert_equal 'John Smith', @jsmith.reload.name
                  end
                  with_settings :user_format => :username do
                    assert_equal 'jsmith', @jsmith.reload.name
                  end
                  with_settings :user_format => :lastname do
                    assert_equal 'Smith', @jsmith.reload.name
                  end
                end
                def test_today_should_return_the_day_according_to_user_time_zone
                  preference = User.find(1).pref
                  date = Date.new(2012, 05, 15)
                  time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
                  Date.stubs(:today).returns(date)
                  Time.stubs(:now).returns(time)
                  preference.update_attribute :time_zone, 'Baku' # UTC+4
                  assert_equal '2012-05-16', User.find(1).today.to_s
                  preference.update_attribute :time_zone, 'La Paz' # UTC-4
                  assert_equal '2012-05-15', User.find(1).today.to_s
                  preference.update_attribute :time_zone, ''
                  assert_equal '2012-05-15', User.find(1).today.to_s
                end
                def test_time_to_date_should_return_the_date_according_to_user_time_zone
                  preference = User.find(1).pref
                  time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
                  preference.update_attribute :time_zone, 'Baku' # UTC+4
                  assert_equal '2012-05-16', User.find(1).time_to_date(time).to_s
                  preference.update_attribute :time_zone, 'La Paz' # UTC-4
                  assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
                  preference.update_attribute :time_zone, ''
                  assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
                end
                def test_fields_for_order_statement_should_return_fields_according_user_format_setting
                  with_settings :user_format => 'lastname_comma_firstname' do
                    assert_equal ['users.lastname', 'users.firstname', 'users.id'],
                                 User.fields_for_order_statement
                  end
                end
                def test_fields_for_order_statement_width_table_name_should_prepend_table_name
                  with_settings :user_format => 'lastname_firstname' do
                    assert_equal ['authors.lastname', 'authors.firstname', 'authors.id'],
                                 User.fields_for_order_statement('authors')
                  end
                end
                def test_fields_for_order_statement_with_blank_format_should_return_default
                  with_settings :user_format => '' do
                    assert_equal ['users.firstname', 'users.lastname', 'users.id'],
                                 User.fields_for_order_statement
                  end
                end
                def test_fields_for_order_statement_with_invalid_format_should_return_default
                  with_settings :user_format => 'foo' do
                    assert_equal ['users.firstname', 'users.lastname', 'users.id'],
                                 User.fields_for_order_statement
                  end
                end
                test ".try_to_login with good credentials should return the user" do
                  user = User.try_to_login("admin", "admin")
                  assert_kind_of User, user
                  assert_equal "admin", user.login
                end
                test ".try_to_login with wrong credentials should return nil" do
                  assert_nil User.try_to_login("admin", "foo")
                end
                def test_try_to_login_with_locked_user_should_return_nil
                  @jsmith.status = User::STATUS_LOCKED
                  @jsmith.save!
                  user = User.try_to_login("jsmith", "jsmith")
-                 assert_equal nil, user
+                 assert_nil user
                end
                def test_try_to_login_with_locked_user_and_not_active_only_should_return_user
                  @jsmith.status = User::STATUS_LOCKED
                  @jsmith.save!
                  user = User.try_to_login("jsmith", "jsmith", false)
                  assert_equal @jsmith, user
                end
                test ".try_to_login should fall-back to case-insensitive if user login is not found as-typed" do
                  user = User.try_to_login("AdMin", "admin")
                  assert_kind_of User, user
                  assert_equal "admin", user.login
                end
                test ".try_to_login should select the exact matching user first" do
                  case_sensitive_user = User.generate! do |user|
                    user.password = "admin123"
                  end
                  # bypass validations to make it appear like existing data
                  case_sensitive_user.update_attribute(:login, 'ADMIN')
                  user = User.try_to_login("ADMIN", "admin123")
                  assert_kind_of User, user
                  assert_equal "ADMIN", user.login
                end
                if ldap_configured?
                  test "#try_to_login using LDAP with failed connection to the LDAP server" do
                    auth_source = AuthSourceLdap.find(1)
                    AuthSource.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError, 'Cannot connect')
-                   assert_equal nil, User.try_to_login('edavis', 'wrong')
+                   assert_nil User.try_to_login('edavis', 'wrong')
                  end
                  test "#try_to_login using LDAP" do
-                   assert_equal nil, User.try_to_login('edavis', 'wrong')
+                   assert_nil User.try_to_login('edavis', 'wrong')
                  end
                  test "#try_to_login using LDAP binding with user's account" do
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
                    auth_source.account_password = ''
                    auth_source.save!
                    ldap_user = User.new(:mail => 'example1@redmine.org', :firstname => 'LDAP', :lastname => 'user', :auth_source_id => 1)
                    ldap_user.login = 'example1'
                    ldap_user.save!
                    assert_equal ldap_user, User.try_to_login('example1', '123456')
                    assert_nil User.try_to_login('example1', '11111')
                  end
                  test "#try_to_login using LDAP on the fly registration" do
                    AuthSourceLdap.find(1).update_attribute :onthefly_register, true
                    assert_difference('User.count') do
                      assert User.try_to_login('edavis', '123456')
                    end
                    assert_no_difference('User.count') do
                      assert User.try_to_login('edavis', '123456')
                    end
                    assert_nil User.try_to_login('example1', '11111')
                  end
                  test "#try_to_login using LDAP on the fly registration and binding with user's account" do
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.update_attribute :onthefly_register, true
                    auth_source = AuthSourceLdap.find(1)
                    auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
                    auth_source.account_password = ''
                    auth_source.save!
                    assert_difference('User.count') do
                      assert User.try_to_login('example1', '123456')
                    end
                    assert_no_difference('User.count') do
                      assert User.try_to_login('example1', '123456')
                    end
                    assert_nil User.try_to_login('example1', '11111')
                  end
                else
                  puts "Skipping LDAP tests."
                end
                def test_create_anonymous
                  AnonymousUser.delete_all
                  anon = User.anonymous
                  assert !anon.new_record?
                  assert_kind_of AnonymousUser, anon
                end
                def test_ensure_single_anonymous_user
                  AnonymousUser.delete_all
                  anon1 = User.anonymous
                  assert !anon1.new_record?
                  assert_kind_of AnonymousUser, anon1
                  anon2 = AnonymousUser.create(
                              :lastname => 'Anonymous', :firstname => '',
                              :login => '', :status => 0)
                  assert_equal 1, anon2.errors.count
                end
                def test_rss_key
                  assert_nil @jsmith.rss_token
                  key = @jsmith.rss_key
                  assert_equal 40, key.length
                  @jsmith.reload
                  assert_equal key, @jsmith.rss_key
                end
                def test_rss_key_should_not_be_generated_twice
                  assert_difference 'Token.count', 1 do
                    key1 = @jsmith.rss_key
                    key2 = @jsmith.rss_key
                    assert_equal key1, key2
                  end
                end
                def test_api_key_should_not_be_generated_twice
                  assert_difference 'Token.count', 1 do
                    key1 = @jsmith.api_key
                    key2 = @jsmith.api_key
                    assert_equal key1, key2
                  end
                end
                test "#api_key should generate a new one if the user doesn't have one" do
                  user = User.generate!(:api_token => nil)
                  assert_nil user.api_token
                  key = user.api_key
                  assert_equal 40, key.length
                  user.reload
                  assert_equal key, user.api_key
                end
                test "#api_key should return the existing api token value" do
                  user = User.generate!
                  token = Token.create!(:action => 'api')
                  user.api_token = token
                  assert user.save
                  assert_equal token.value, user.api_key
                end
                test "#find_by_api_key should return nil if no matching key is found" do
                  assert_nil User.find_by_api_key('zzzzzzzzz')
                end
                test "#find_by_api_key should return nil if the key is found for an inactive user" do
                  user = User.generate!
                  user.status = User::STATUS_LOCKED
                  token = Token.create!(:action => 'api')
                  user.api_token = token
                  user.save
                  assert_nil User.find_by_api_key(token.value)
                end
                test "#find_by_api_key should return the user if the key is found for an active user" do
                  user = User.generate!
                  token = Token.create!(:action => 'api')
                  user.api_token = token
                  user.save
                  assert_equal user, User.find_by_api_key(token.value)
                end
                def test_default_admin_account_changed_should_return_false_if_account_was_not_changed
                  user = User.find_by_login("admin")
                  user.password = "admin"
                  assert user.save(:validate => false)
                  assert_equal false, User.default_admin_account_changed?
                end
                def test_default_admin_account_changed_should_return_true_if_password_was_changed
                  user = User.find_by_login("admin")
                  user.password = "newpassword"
                  user.save!
                  assert_equal true, User.default_admin_account_changed?
                end
                def test_default_admin_account_changed_should_return_true_if_account_is_disabled
                  user = User.find_by_login("admin")
                  user.password = "admin"
                  user.status = User::STATUS_LOCKED
                  assert user.save(:validate => false)
                  assert_equal true, User.default_admin_account_changed?
                end
                def test_default_admin_account_changed_should_return_true_if_account_does_not_exist
                  user = User.find_by_login("admin")
                  user.destroy
                  assert_equal true, User.default_admin_account_changed?
                end
                def test_membership_with_project_should_return_membership
                  project = Project.find(1)
                  membership = @jsmith.membership(project)
                  assert_kind_of Member, membership
                  assert_equal @jsmith, membership.user
                  assert_equal project, membership.project
                end
                def test_membership_with_project_id_should_return_membership
                  project = Project.find(1)
                  membership = @jsmith.membership(1)
                  assert_kind_of Member, membership
                  assert_equal @jsmith, membership.user
                  assert_equal project, membership.project
                end
                def test_membership_for_non_member_should_return_nil
                  project = Project.find(1)
                  user = User.generate!
                  membership = user.membership(1)
                  assert_nil membership
                end
                def test_roles_for_project_with_member_on_public_project_should_return_roles_and_non_member
                  roles = @jsmith.roles_for_project(Project.find(1))
                  assert_kind_of Role, roles.first
                  assert_equal ["Manager"], roles.map(&:name)
                end
                def test_roles_for_project_with_member_on_private_project_should_return_roles
                  Project.find(1).update_attribute :is_public, false
                  roles = @jsmith.roles_for_project(Project.find(1))
                  assert_kind_of Role, roles.first
                  assert_equal ["Manager"], roles.map(&:name)
                end
                def test_roles_for_project_with_non_member_with_public_project_should_return_non_member
                  set_language_if_valid 'en'
                  roles = User.find(8).roles_for_project(Project.find(1))
                  assert_equal ["Non member"], roles.map(&:name)
                end
                def test_roles_for_project_with_non_member_with_public_project_and_override_should_return_override_roles
                  project = Project.find(1)
                  Member.create!(:project => project, :principal => Group.non_member, :role_ids => [1, 2])
                  roles = User.find(8).roles_for_project(project)
                  assert_equal ["Developer", "Manager"], roles.map(&:name).sort
                end
                def test_roles_for_project_with_non_member_with_private_project_should_return_no_roles
                  Project.find(1).update_attribute :is_public, false
                  roles = User.find(8).roles_for_project(Project.find(1))
                  assert_equal [], roles.map(&:name)
                end
                def test_roles_for_project_with_non_member_with_private_project_and_override_should_return_no_roles
                  project = Project.find(1)
                  project.update_attribute :is_public, false
                  Member.create!(:project => project, :principal => Group.non_member, :role_ids => [1, 2])
                  roles = User.find(8).roles_for_project(project)
                  assert_equal [], roles.map(&:name).sort
                end
                def test_roles_for_project_with_anonymous_with_public_project_should_return_anonymous
                  set_language_if_valid 'en'
                  roles = User.anonymous.roles_for_project(Project.find(1))
                  assert_equal ["Anonymous"], roles.map(&:name)
                end
                def test_roles_for_project_with_anonymous_with_public_project_and_override_should_return_override_roles
                  project = Project.find(1)
                  Member.create!(:project => project, :principal => Group.anonymous, :role_ids => [1, 2])
                  roles = User.anonymous.roles_for_project(project)
                  assert_equal ["Developer", "Manager"], roles.map(&:name).sort
                end
                def test_roles_for_project_with_anonymous_with_private_project_should_return_no_roles
                  Project.find(1).update_attribute :is_public, false
                  roles = User.anonymous.roles_for_project(Project.find(1))
                  assert_equal [], roles.map(&:name)
                end
                def test_roles_for_project_with_anonymous_with_private_project_and_override_should_return_no_roles
                  project = Project.find(1)
                  project.update_attribute :is_public, false
                  Member.create!(:project => project, :principal => Group.anonymous, :role_ids => [1, 2])
                  roles = User.anonymous.roles_for_project(project)
                  assert_equal [], roles.map(&:name).sort
                end
                def test_roles_for_project_should_be_unique
                  m = Member.new(:user_id => 1, :project_id => 1)
                  m.member_roles.build(:role_id => 1)
                  m.member_roles.build(:role_id => 1)
                  m.save!
                  user = User.find(1)
                  project = Project.find(1)
                  assert_equal 1, user.roles_for_project(project).size
                  assert_equal [1], user.roles_for_project(project).map(&:id)
                end
                def test_projects_by_role_for_user_with_role
                  user = User.find(2)
                  assert_kind_of Hash, user.projects_by_role
                  assert_equal 2, user.projects_by_role.size
                  assert_equal [1,5], user.projects_by_role[Role.find(1)].collect(&:id).sort
                  assert_equal [2], user.projects_by_role[Role.find(2)].collect(&:id).sort
                end
                def test_accessing_projects_by_role_with_no_projects_should_return_an_empty_array
                  user = User.find(2)
                  assert_equal [], user.projects_by_role[Role.find(3)]
                  # should not update the hash
                  assert_nil user.projects_by_role.values.detect(&:blank?)
                end
                def test_projects_by_role_for_user_with_no_role
                  user = User.generate!
                  assert_equal({}, user.projects_by_role)
                end
                def test_projects_by_role_for_anonymous
                  assert_equal({}, User.anonymous.projects_by_role)
                end
                def test_valid_notification_options
                  # without memberships
                  assert_equal 5, User.find(7).valid_notification_options.size
                  # with memberships
                  assert_equal 6, User.find(2).valid_notification_options.size
                end
                def test_valid_notification_options_class_method
                  assert_equal 5, User.valid_notification_options.size
                  assert_equal 5, User.valid_notification_options(User.find(7)).size
                  assert_equal 6, User.valid_notification_options(User.find(2)).size
                end
                def test_notified_project_ids_setter_should_coerce_to_unique_integer_array
                  @jsmith.notified_project_ids = ["1", "123", "2u", "wrong", "12", 6, 12, -35, ""]
                  assert_equal [1, 123, 2, 12, 6], @jsmith.notified_projects_ids
                end
                def test_mail_notification_all
                  @jsmith.mail_notification = 'all'
                  @jsmith.notified_project_ids = []
                  @jsmith.save
                  @jsmith.reload
                  assert @jsmith.projects.first.recipients.include?(@jsmith.mail)
                end
                def test_mail_notification_selected
                  @jsmith.mail_notification = 'selected'
                  @jsmith.notified_project_ids = [1]
                  @jsmith.save
                  @jsmith.reload
                  assert Project.find(1).recipients.include?(@jsmith.mail)
                end
                def test_mail_notification_only_my_events
                  @jsmith.mail_notification = 'only_my_events'
                  @jsmith.notified_project_ids = []
                  @jsmith.save
                  @jsmith.reload
                  assert !@jsmith.projects.first.recipients.include?(@jsmith.mail)
                end
                def test_comments_sorting_preference
                  assert !@jsmith.wants_comments_in_reverse_order?
                  @jsmith.pref.comments_sorting = 'asc'
                  assert !@jsmith.wants_comments_in_reverse_order?
                  @jsmith.pref.comments_sorting = 'desc'
                  assert @jsmith.wants_comments_in_reverse_order?
                end
                def test_find_by_mail_should_be_case_insensitive
                  u = User.find_by_mail('JSmith@somenet.foo')
                  assert_not_nil u
                  assert_equal 'jsmith@somenet.foo', u.mail
                end
                def test_random_password
                  u = User.new
                  u.random_password
                  assert !u.password.blank?
                  assert !u.password_confirmation.blank?
                end
                test "#change_password_allowed? should be allowed if no auth source is set" do
                  user = User.generate!
                  assert user.change_password_allowed?
                end
                test "#change_password_allowed? should delegate to the auth source" do
                  user = User.generate!
                  allowed_auth_source = AuthSource.generate!
                  def allowed_auth_source.allow_password_changes?; true; end
                  denied_auth_source = AuthSource.generate!
                  def denied_auth_source.allow_password_changes?; false; end
                  assert user.change_password_allowed?
                  user.auth_source = allowed_auth_source
                  assert user.change_password_allowed?, "User not allowed to change password, though auth source does"
                  user.auth_source = denied_auth_source
                  assert !user.change_password_allowed?, "User allowed to change password, though auth source does not"
                end
                def test_own_account_deletable_should_be_true_with_unsubscrive_enabled
                  with_settings :unsubscribe => '1' do
                    assert_equal true, User.find(2).own_account_deletable?
                  end
                end
                def test_own_account_deletable_should_be_false_with_unsubscrive_disabled
                  with_settings :unsubscribe => '0' do
                    assert_equal false, User.find(2).own_account_deletable?
                  end
                end
                def test_own_account_deletable_should_be_false_for_a_single_admin
                  User.where(["admin = ? AND id <> ?", true, 1]).delete_all
                  with_settings :unsubscribe => '1' do
                    assert_equal false, User.find(1).own_account_deletable?
                  end
                end
                def test_own_account_deletable_should_be_true_for_an_admin_if_other_admin_exists
                  User.generate! do |user|
                    user.admin = true
                  end
                  with_settings :unsubscribe => '1' do
                    assert_equal true, User.find(1).own_account_deletable?
                  end
                end
                test "#allowed_to? for archived project should return false" do
                  project = Project.find(1)
                  project.archive
                  project.reload
                  assert_equal false, @admin.allowed_to?(:view_issues, project)
                end
                test "#allowed_to? for closed project should return true for read actions" do
                  project = Project.find(1)
                  project.close
                  project.reload
                  assert_equal false, @admin.allowed_to?(:edit_project, project)
                  assert_equal true, @admin.allowed_to?(:view_project, project)
                end
                test "#allowed_to? for project with module disabled should return false" do
                  project = Project.find(1)
                  project.enabled_module_names = ["issue_tracking"]
                  assert_equal true, @admin.allowed_to?(:add_issues, project)
                  assert_equal false, @admin.allowed_to?(:view_wiki_pages, project)
                end
                test "#allowed_to? for admin users should return true" do
                  project = Project.find(1)
                  assert ! @admin.member_of?(project)
                  %w(edit_issues delete_issues manage_news add_documents manage_wiki).each do |p|
                    assert_equal true, @admin.allowed_to?(p.to_sym, project)
                  end
                end
                test "#allowed_to? for normal users" do
                  project = Project.find(1)
                  assert_equal true, @jsmith.allowed_to?(:delete_messages, project)    #Manager
                  assert_equal false, @dlopper.allowed_to?(:delete_messages, project) #Developper
                end
                test "#allowed_to? with empty array should return false" do
                  assert_equal false, @admin.allowed_to?(:view_project, [])
                end
                test "#allowed_to? with multiple projects" do
                  assert_equal true, @admin.allowed_to?(:view_project, Project.all.to_a)
                  assert_equal false, @dlopper.allowed_to?(:view_project, Project.all.to_a) #cannot see Project(2)
                  assert_equal true, @jsmith.allowed_to?(:edit_issues, @jsmith.projects.to_a) #Manager or Developer everywhere
                  assert_equal false, @jsmith.allowed_to?(:delete_issue_watchers, @jsmith.projects.to_a) #Dev cannot delete_issue_watchers
                end
                test "#allowed_to? with with options[:global] should return true if user has one role with the permission" do
                  @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
                  @anonymous = User.find(6)
                  assert_equal true, @jsmith.allowed_to?(:delete_issue_watchers, nil, :global => true)
                  assert_equal false, @dlopper2.allowed_to?(:delete_issue_watchers, nil, :global => true)
                  assert_equal true, @dlopper2.allowed_to?(:add_issues, nil, :global => true)
                  assert_equal false, @anonymous.allowed_to?(:add_issues, nil, :global => true)
                  assert_equal true, @anonymous.allowed_to?(:view_issues, nil, :global => true)
                end
                # this is just a proxy method, the test only calls it to ensure it doesn't break trivially
                test "#allowed_to_globally?" do
                  @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
                  @anonymous = User.find(6)
                  assert_equal true, @jsmith.allowed_to_globally?(:delete_issue_watchers)
                  assert_equal false, @dlopper2.allowed_to_globally?(:delete_issue_watchers)
                  assert_equal true, @dlopper2.allowed_to_globally?(:add_issues)
                  assert_equal false, @anonymous.allowed_to_globally?(:add_issues)
                  assert_equal true, @anonymous.allowed_to_globally?(:view_issues)
                end
                def test_notify_about_issue
                  project = Project.find(1)
                  author = User.generate!
                  assignee = User.generate!
                  Member.create!(:user => assignee, :project => project, :role_ids => [1])
                  member = User.generate!
                  Member.create!(:user => member, :project => project, :role_ids => [1])
                  issue = Issue.generate!(:project => project, :assigned_to => assignee, :author => author)
                  tests = {
                    author => %w(all only_my_events only_owner selected),
                    assignee => %w(all only_my_events only_assigned selected),
                    member => %w(all)
                  }
                  tests.each do |user, expected|
                    User::MAIL_NOTIFICATION_OPTIONS.map(&:first).each do |option|
                      user.mail_notification = option
                      assert_equal expected.include?(option), user.notify_about?(issue)
                    end
                  end
                end
                def test_notify_about_issue_for_previous_assignee
                  assignee = User.generate!(:mail_notification => 'only_assigned')
                  Member.create!(:user => assignee, :project_id => 1, :role_ids => [1])
                  new_assignee = User.generate!(:mail_notification => 'only_assigned')
                  Member.create!(:user => new_assignee, :project_id => 1, :role_ids => [1])
                  issue = Issue.generate!(:assigned_to => assignee)
                  assert assignee.notify_about?(issue)
                  assert !new_assignee.notify_about?(issue)
                  issue.assigned_to = new_assignee
                  assert assignee.notify_about?(issue)
                  assert new_assignee.notify_about?(issue)
                  issue.save!
                  assert !assignee.notify_about?(issue)
                  assert new_assignee.notify_about?(issue)
                end
                def test_notify_about_news
                  user = User.generate!
                  news = News.new
                  User::MAIL_NOTIFICATION_OPTIONS.map(&:first).each do |option|
                    user.mail_notification = option
                    assert_equal (option != 'none'), user.notify_about?(news)
                  end
                end
                def test_salt_unsalted_passwords
                  # Restore a user with an unsalted password
                  user = User.find(1)
                  user.salt = nil
                  user.hashed_password = User.hash_password("unsalted")
                  user.save!
                  User.salt_unsalted_passwords!
                  user.reload
                  # Salt added
                  assert !user.salt.blank?
                  # Password still valid
                  assert user.check_password?("unsalted")
                  assert_equal user, User.try_to_login(user.login, "unsalted")
                end
                if Object.const_defined?(:OpenID)
                  def test_setting_identity_url
                    normalized_open_id_url = 'http://example.com/'
                    u = User.new( :identity_url => 'http://example.com/' )
                    assert_equal normalized_open_id_url, u.identity_url
                  end
                  def test_setting_identity_url_without_trailing_slash
                    normalized_open_id_url = 'http://example.com/'
                    u = User.new( :identity_url => 'http://example.com' )
                    assert_equal normalized_open_id_url, u.identity_url
                  end
                  def test_setting_identity_url_without_protocol
                    normalized_open_id_url = 'http://example.com/'
                    u = User.new( :identity_url => 'example.com' )
                    assert_equal normalized_open_id_url, u.identity_url
                  end
                  def test_setting_blank_identity_url
                    u = User.new( :identity_url => 'example.com' )
                    u.identity_url = ''
                    assert u.identity_url.blank?
                  end
                  def test_setting_invalid_identity_url
                    u = User.new( :identity_url => 'this is not an openid url' )
                    assert u.identity_url.blank?
                  end
                else
                  puts "Skipping openid tests."
                end
              end

test/unit/version_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 VersionTest < ActiveSupport::TestCase
                fixtures :projects, :users, :issues, :issue_statuses, :trackers,
                         :enumerations, :versions, :projects_trackers
                def test_create
                  v = Version.new(:project => Project.find(1), :name => '1.1',
                                  :effective_date => '2011-03-25')
                  assert v.save
                  assert_equal 'open', v.status
                  assert_equal 'none', v.sharing
                end
                def test_create_as_default_project_version
                  project = Project.find(1)
                  v = Version.new(:project => project, :name => '1.1',
                                  :default_project_version => '1')
                  assert v.save
                  assert_equal v, project.reload.default_version
                end
                def test_create_not_as_default_project_version
                  project = Project.find(1)
                  v = Version.new(:project => project, :name => '1.1',
                                  :default_project_version => '0')
                  assert v.save
                  assert_nil project.reload.default_version
                end
                def test_invalid_effective_date_validation
                  v = Version.new(:project => Project.find(1), :name => '1.1',
                                  :effective_date => '99999-01-01')
                  assert !v.valid?
                  v.effective_date = '2012-11-33'
                  assert !v.valid?
                  v.effective_date = '2012-31-11'
                  assert !v.valid?
                  v.effective_date = '-2012-31-11'
                  assert !v.valid?
                  v.effective_date = 'ABC'
                  assert !v.valid?
                  assert_include I18n.translate('activerecord.errors.messages.not_a_date'),
                                 v.errors[:effective_date]
                end
                def test_progress_should_be_0_with_no_assigned_issues
                  project = Project.find(1)
                  v = Version.create!(:project => project, :name => 'Progress')
                  assert_equal 0, v.completed_percent
                  assert_equal 0, v.closed_percent
                end
                def test_progress_should_be_0_with_unbegun_assigned_issues
                  project = Project.find(1)
                  v = Version.create!(:project => project, :name => 'Progress')
                  add_issue(v)
                  add_issue(v, :done_ratio => 0)
                  assert_progress_equal 0, v.completed_percent
                  assert_progress_equal 0, v.closed_percent
                end
                def test_progress_should_be_100_with_closed_assigned_issues
                  project = Project.find(1)
                  status = IssueStatus.where(:is_closed => true).first
                  v = Version.create!(:project => project, :name => 'Progress')
                  add_issue(v, :status => status)
                  add_issue(v, :status => status, :done_ratio => 20)
                  add_issue(v, :status => status, :done_ratio => 70, :estimated_hours => 25)
                  add_issue(v, :status => status, :estimated_hours => 15)
                  assert_progress_equal 100.0, v.completed_percent
                  assert_progress_equal 100.0, v.closed_percent
                end
                def test_progress_should_consider_done_ratio_of_open_assigned_issues
                  project = Project.find(1)
                  v = Version.create!(:project => project, :name => 'Progress')
                  add_issue(v)
                  add_issue(v, :done_ratio => 20)
                  add_issue(v, :done_ratio => 70)
                  assert_progress_equal (0.0 + 20.0 + 70.0)/3, v.completed_percent
                  assert_progress_equal 0, v.closed_percent
                end
                def test_progress_should_consider_closed_issues_as_completed
                  project = Project.find(1)
                  v = Version.create!(:project => project, :name => 'Progress')
                  add_issue(v)
                  add_issue(v, :done_ratio => 20)
                  add_issue(v, :status => IssueStatus.where(:is_closed => true).first)
                  assert_progress_equal (0.0 + 20.0 + 100.0)/3, v.completed_percent
                  assert_progress_equal (100.0)/3, v.closed_percent
                end
                def test_progress_should_consider_estimated_hours_to_weight_issues
                  project = Project.find(1)
                  v = Version.create!(:project => project, :name => 'Progress')
                  add_issue(v, :estimated_hours => 10)
                  add_issue(v, :estimated_hours => 20, :done_ratio => 30)
                  add_issue(v, :estimated_hours => 40, :done_ratio => 10)
                  add_issue(v, :estimated_hours => 25, :status => IssueStatus.where(:is_closed => true).first)
                  assert_progress_equal (10.0*0 + 20.0*0.3 + 40*0.1 + 25.0*1)/95.0*100, v.completed_percent
                  assert_progress_equal 25.0/95.0*100, v.closed_percent
                end
                def test_progress_should_consider_average_estimated_hours_to_weight_unestimated_issues
                  project = Project.find(1)
                  v = Version.create!(:project => project, :name => 'Progress')
                  add_issue(v, :done_ratio => 20)
                  add_issue(v, :status => IssueStatus.where(:is_closed => true).first)
                  add_issue(v, :estimated_hours => 10, :done_ratio => 30)
                  add_issue(v, :estimated_hours => 40, :done_ratio => 10)
                  assert_progress_equal (25.0*0.2 + 25.0*1 + 10.0*0.3 + 40.0*0.1)/100.0*100, v.completed_percent
                  assert_progress_equal 25.0/100.0*100, v.closed_percent
                end
                def test_should_sort_scheduled_then_unscheduled_versions
                  Version.delete_all
                  v4 = Version.create!(:project_id => 1, :name => 'v4')
                  v3 = Version.create!(:project_id => 1, :name => 'v2', :effective_date => '2012-07-14')
                  v2 = Version.create!(:project_id => 1, :name => 'v1')
                  v1 = Version.create!(:project_id => 1, :name => 'v3', :effective_date => '2012-08-02')
                  v5 = Version.create!(:project_id => 1, :name => 'v5', :effective_date => '2012-07-02')
                  assert_equal [v5, v3, v1, v2, v4], [v1, v2, v3, v4, v5].sort
                  assert_equal [v5, v3, v1, v2, v4], Version.sorted.to_a
                end
                def test_should_sort_versions_with_same_date_by_name
                  v1 = Version.new(:effective_date => '2014-12-03', :name => 'v2')
                  v2 = Version.new(:effective_date => '2014-12-03', :name => 'v1')
                  assert_equal [v2, v1], [v1, v2].sort
                end
                def test_completed_should_be_false_when_due_today
                  version = Version.create!(:project_id => 1, :effective_date => Date.today, :name => 'Due today')
                  assert_equal false, version.completed?
                end
                def test_completed_should_be_true_when_closed
                  version = Version.create!(:project_id => 1, :status => 'closed', :name => 'Closed')
                  assert_equal true, version.completed?
                end
                test "#behind_schedule? should be false if there are no issues assigned" do
                  version = Version.generate!(:effective_date => Date.yesterday)
                  assert_equal false, version.behind_schedule?
                end
                test "#behind_schedule? should be false if there is no effective_date" do
                  version = Version.generate!(:effective_date => nil)
                  assert_equal false, version.behind_schedule?
                end
                test "#behind_schedule? should be false if all of the issues are ahead of schedule" do
                  version = Version.create!(:project_id => 1, :name => 'test', :effective_date => 7.days.from_now.to_date)
                  add_issue(version, :start_date => 7.days.ago, :done_ratio => 60) # 14 day span, 60% done, 50% time left
                  add_issue(version, :start_date => 7.days.ago, :done_ratio => 60) # 14 day span, 60% done, 50% time left
                  assert_equal 60, version.completed_percent
                  assert_equal false, version.behind_schedule?
                end
                test "#behind_schedule? should be true if any of the issues are behind schedule" do
                  version = Version.create!(:project_id => 1, :name => 'test', :effective_date => 7.days.from_now.to_date)
                  add_issue(version, :start_date => 7.days.ago, :done_ratio => 60) # 14 day span, 60% done, 50% time left
                  add_issue(version, :start_date => 7.days.ago, :done_ratio => 20) # 14 day span, 20% done, 50% time left
                  assert_equal 40, version.completed_percent
                  assert_equal true, version.behind_schedule?
                end
                test "#behind_schedule? should be false if all of the issues are complete" do
                  version = Version.create!(:project_id => 1, :name => 'test', :effective_date => 7.days.from_now.to_date)
                  add_issue(version, :start_date => 14.days.ago, :done_ratio => 100, :status => IssueStatus.find(5)) # 7 day span
                  add_issue(version, :start_date => 14.days.ago, :done_ratio => 100, :status => IssueStatus.find(5)) # 7 day span
                  assert_equal 100, version.completed_percent
                  assert_equal false, version.behind_schedule?
                end
                test "#estimated_hours should return 0 with no assigned issues" do
                  version = Version.generate!
                  assert_equal 0, version.estimated_hours
                end
                test "#estimated_hours should return 0 with no estimated hours" do
                  version = Version.create!(:project_id => 1, :name => 'test')
                  add_issue(version)
                  assert_equal 0, version.estimated_hours
                end
                test "#estimated_hours should return return the sum of estimated hours" do
                  version = Version.create!(:project_id => 1, :name => 'test')
                  add_issue(version, :estimated_hours => 2.5)
                  add_issue(version, :estimated_hours => 5)
                  assert_equal 7.5, version.estimated_hours
                end
                test "#estimated_hours should return the sum of leaves estimated hours" do
                  version = Version.create!(:project_id => 1, :name => 'test')
                  parent = add_issue(version)
                  add_issue(version, :estimated_hours => 2.5, :parent_issue_id => parent.id)
                  add_issue(version, :estimated_hours => 5, :parent_issue_id => parent.id)
                  assert_equal 7.5, version.estimated_hours
                end
                test "should update all issue's fixed_version associations in case the hierarchy changed XXX" do
                  User.current = User.find(1) # Need the admin's permissions
                  @version = Version.find(7)
                  # Separate hierarchy
                  project_1_issue = Issue.find(1)
                  project_1_issue.fixed_version = @version
                  assert project_1_issue.save, project_1_issue.errors.full_messages.to_s
                  project_5_issue = Issue.find(6)
                  project_5_issue.fixed_version = @version
                  assert project_5_issue.save
                  # Project
                  project_2_issue = Issue.find(4)
                  project_2_issue.fixed_version = @version
                  assert project_2_issue.save
                  # Update the sharing
                  @version.sharing = 'none'
                  assert @version.save
                  # Project 1 now out of the shared scope
                  project_1_issue.reload
-                 assert_equal nil, project_1_issue.fixed_version,
+                 assert_nil project_1_issue.fixed_version,
                              "Fixed version is still set after changing the Version's sharing"
                  # Project 5 now out of the shared scope
                  project_5_issue.reload
-                 assert_equal nil, project_5_issue.fixed_version,
+                 assert_nil project_5_issue.fixed_version,
                              "Fixed version is still set after changing the Version's sharing"
                  # Project 2 issue remains
                  project_2_issue.reload
                  assert_equal @version, project_2_issue.fixed_version
                end
                def test_deletable_should_return_true_when_not_referenced
                  version = Version.generate!
                  assert_equal true, version.deletable?
                end
                def test_deletable_should_return_false_when_referenced_by_an_issue
                  version = Version.generate!
                  Issue.generate!(:fixed_version => version)
                  assert_equal false, version.deletable?
                end
                def test_deletable_should_return_false_when_referenced_by_a_custom_field
                  version = Version.generate!
                  field = IssueCustomField.generate!(:field_format => 'version')
                  value = CustomValue.create!(:custom_field => field, :customized => Issue.first, :value => version.id)
                  assert_equal false, version.deletable?
                end
                private
                def add_issue(version, attributes={})
                  Issue.create!({:project => version.project,
                                 :fixed_version => version,
                                 :subject => 'Test',
                                 :author => User.first,
                                 :tracker => version.project.trackers.first}.merge(attributes))
                end
                def assert_progress_equal(expected_float, actual_float, message="")
                  assert_in_delta(expected_float, actual_float, 0.000001, message="")
                end
              end

test/unit/wiki_page_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 WikiPageTest < ActiveSupport::TestCase
                fixtures :projects, :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions
                def setup
                  @wiki = Wiki.find(1)
                  @page = @wiki.pages.first
                end
                def test_create
                  page = WikiPage.new(:wiki => @wiki)
                  assert !page.save
                  assert_equal 1, page.errors.count
                  page.title = "Page"
                  assert page.save
                  page.reload
                  assert !page.protected?
                  @wiki.reload
                  assert @wiki.pages.include?(page)
                end
                def test_sidebar_should_be_protected_by_default
                  page = @wiki.find_or_new_page('sidebar')
                  assert page.new_record?
                  assert page.protected?
                end
                def test_find_or_new_page
                  page = @wiki.find_or_new_page("CookBook documentation")
                  assert_kind_of WikiPage, page
                  assert !page.new_record?
                  page = @wiki.find_or_new_page("Non existing page")
                  assert_kind_of WikiPage, page
                  assert page.new_record?
                end
                def test_parent_title
                  page = WikiPage.find_by_title('Another_page')
                  assert_nil page.parent_title
                  page = WikiPage.find_by_title('Page_with_an_inline_image')
                  assert_equal 'CookBook documentation', page.parent_title
                end
                def test_assign_parent
                  page = WikiPage.find_by_title('Another_page')
                  page.parent_title = 'CookBook documentation'
                  assert page.save
                  page.reload
                  assert_equal WikiPage.find_by_title('CookBook_documentation'), page.parent
                end
                def test_unassign_parent
                  page = WikiPage.find_by_title('Page_with_an_inline_image')
                  page.parent_title = ''
                  assert page.save
                  page.reload
                  assert_nil page.parent
                end
                def test_parent_validation
                  page = WikiPage.find_by_title('CookBook_documentation')
                  # A page that doesn't exist
                  page.parent_title = 'Unknown title'
                  assert !page.save
                  assert_include I18n.translate('activerecord.errors.messages.invalid'),
                                 page.errors[:parent_title]
                  # A child page
                  page.parent_title = 'Page_with_an_inline_image'
                  assert !page.save
                  assert_include I18n.translate('activerecord.errors.messages.circular_dependency'),
                                 page.errors[:parent_title]
                  # The page itself
                  page.parent_title = 'CookBook_documentation'
                  assert !page.save
                  assert_include I18n.translate('activerecord.errors.messages.circular_dependency'),
                                 page.errors[:parent_title]
                  page.parent_title = 'Another_page'
                  assert page.save
                end
                def test_move_child_should_clear_parent
                  parent = WikiPage.create!(:wiki_id => 1, :title => 'Parent')
                  child = WikiPage.create!(:wiki_id => 1, :title => 'Child', :parent => parent)
                  child.wiki_id = 2
                  child.save!
-                 assert_equal nil, child.reload.parent_id
+                 assert_nil child.reload.parent_id
                end
                def test_move_parent_should_move_child_page
                  parent = WikiPage.create!(:wiki_id => 1, :title => 'Parent')
                  child = WikiPage.create!(:wiki_id => 1, :title => 'Child', :parent => parent)
                  parent.reload
                  parent.wiki_id = 2
                  parent.save!
                  assert_equal 2, child.reload.wiki_id
                  assert_equal parent, child.parent
                end
                def test_move_parent_with_child_with_duplicate_name_should_not_move_child
                  parent = WikiPage.create!(:wiki_id => 1, :title => 'Parent')
                  child = WikiPage.create!(:wiki_id => 1, :title => 'Child', :parent_id => parent.id)
                  parent.reload
                  # page with the same name as the child in the target wiki
                  WikiPage.create!(:wiki_id => 2, :title => 'Child')
                  parent.wiki_id = 2
                  parent.save!
                  parent.reload
                  assert_equal 2, parent.wiki_id
                  child.reload
                  assert_equal 1, child.wiki_id
                  assert_nil child.parent_id
                end
                def test_destroy
                  page = WikiPage.find(1)
                  page.destroy
                  assert_nil WikiPage.find_by_id(1)
                  # make sure that page content and its history are deleted
                  assert_equal 0, WikiContent.where(:page_id => 1).count
                  assert_equal 0, WikiContent.versioned_class.where(:page_id => 1).count
                end
                def test_destroy_should_not_nullify_children
                  page = WikiPage.find(2)
                  child_ids = page.child_ids
                  assert child_ids.any?
                  page.destroy
                  assert_nil WikiPage.find_by_id(2)
                  children = WikiPage.where(:id => child_ids)
                  assert_equal child_ids.size, children.count
                  children.each do |child|
                    assert_nil child.parent_id
                  end
                end
                def test_with_updated_on_scope_should_preload_updated_on_and_version
                  page = WikiPage.with_updated_on.where(:id => 1).first
                  # make the assertions fail if attributes are not preloaded
                  WikiContent.update_all(:updated_on => '2001-01-01 10:00:00', :version => 1)
                  assert_equal Time.gm(2007, 3, 6, 23, 10, 51), page.updated_on
                  assert_equal 3, page.version
                end
                def test_descendants
                  page = WikiPage.create!(:wiki => @wiki, :title => 'Parent')
                  child1 = WikiPage.create!(:wiki => @wiki, :title => 'Child1', :parent => page)
                  child11 = WikiPage.create!(:wiki => @wiki, :title => 'Child11', :parent => child1)
                  child111 = WikiPage.create!(:wiki => @wiki, :title => 'Child111', :parent => child11)
                  child2 = WikiPage.create!(:wiki => @wiki, :title => 'Child2', :parent => page)
                  assert_equal %w(Child1 Child11 Child111 Child2), page.descendants.map(&:title).sort
                  assert_equal %w(Child1 Child11 Child111 Child2), page.descendants(nil).map(&:title).sort
                  assert_equal %w(Child1 Child11 Child2), page.descendants(2).map(&:title).sort
                  assert_equal %w(Child1 Child2), page.descendants(1).map(&:title).sort
                  assert_equal %w(Child1 Child11 Child111 Child2 Parent), page.self_and_descendants.map(&:title).sort
                  assert_equal %w(Child1 Child11 Child111 Child2 Parent), page.self_and_descendants(nil).map(&:title).sort
                  assert_equal %w(Child1 Child11 Child2 Parent), page.self_and_descendants(2).map(&:title).sort
                  assert_equal %w(Child1 Child2 Parent), page.self_and_descendants(1).map(&:title).sort
                end
                def test_diff_for_page_with_deleted_version_should_pick_the_previous_available_version
                  WikiContent::Version.find_by_page_id_and_version(1, 2).destroy
                  page = WikiPage.find(1)
                  diff = page.diff(3)
                  assert_not_nil diff
                  assert_equal 3, diff.content_to.version
                  assert_equal 1, diff.content_from.version
                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