jro_apps/redmine Commit - r13510:d85f73a30d48

Upgrade to Rails 4.2.0 (#14534)....

Jean-Philippe Lang -

r13510:d85f73a30d48

parent child

Context file:

r13510:d85f73a30d48

Expand all files

The requested changes are too big and content was truncated. Show full diff

Gemfile +3 -2

              source 'https://rubygems.org'
-             gem "rails", "4.1.8"
+             gem "rails", "4.2.0"
              gem "jquery-rails", "~> 3.1.1"
              gem "coderay", "~> 1.1.0"
              gem "builder", ">= 3.0.4"
              gem "request_store", "1.0.5"
              gem "mime-types"
              gem "protected_attributes"
              gem "actionpack-action_caching"
              gem "actionpack-xml_parser"
              # Windows does not include zoneinfo files, so bundle the tzinfo-data gem
              gem 'tzinfo-data', platforms: [:mingw, :x64_mingw, :mswin, :jruby]
              gem "rbpdf", "~> 1.18.4"
              # Optional gem for LDAP authentication
              group :ldap do
                gem "net-ldap", "~> 0.3.1"
              end
              # Optional gem for OpenID authentication
              group :openid do
                gem "ruby-openid", "~> 2.3.0", :require => "openid"
                gem "rack-openid"
              end
              platforms :mri, :mingw, :x64_mingw do
                # Optional gem for exporting the gantt to a PNG file, not supported with jruby
                group :rmagick do
                  gem "rmagick", ">= 2.0.0"
                end
                # Optional Markdown support, not for JRuby
                group :markdown do
                  gem "redcarpet", "~> 3.1.2"
                end
              end
              platforms :jruby do
                # jruby-openssl is bundled with JRuby 1.7.0
                gem "jruby-openssl" if Object.const_defined?(:JRUBY_VERSION) && JRUBY_VERSION < '1.7.0'
                gem "activerecord-jdbc-adapter", "~> 1.3.2"
              end
              # Include database gems for the adapters found in the database
              # configuration file
              require 'erb'
              require 'yaml'
              database_file = File.join(File.dirname(__FILE__), "config/database.yml")
              if File.exist?(database_file)
                database_config = YAML::load(ERB.new(IO.read(database_file)).result)
                adapters = database_config.values.map {|c| c['adapter']}.compact.uniq
                if adapters.any?
                  adapters.each do |adapter|
                    case adapter
                    when 'mysql2'
                      gem "mysql2", "~> 0.3.11", :platforms => [:mri, :mingw, :x64_mingw]
                      gem "activerecord-jdbcmysql-adapter", :platforms => :jruby
                    when 'mysql'
                      gem "activerecord-jdbcmysql-adapter", :platforms => :jruby
                    when /postgresql/
                      gem "pg", "~> 0.17.1", :platforms => [:mri, :mingw, :x64_mingw]
                      gem "activerecord-jdbcpostgresql-adapter", :platforms => :jruby
                    when /sqlite3/
                      gem "sqlite3", :platforms => [:mri, :mingw, :x64_mingw]
                      gem "activerecord-jdbcsqlite3-adapter", "1.3.11", :platforms => :jruby
                    when /sqlserver/
                      gem "tiny_tds", "~> 0.6.2", :platforms => [:mri, :mingw, :x64_mingw]
                      gem "activerecord-sqlserver-adapter", :platforms => [:mri, :mingw, :x64_mingw]
                    else
                      warn("Unknown database adapter `#{adapter}` found in config/database.yml, use Gemfile.local to load your own database gems")
                    end
                  end
                else
                  warn("No adapter found in config/database.yml, please configure it first")
                end
              else
                warn("Please configure your config/database.yml first")
              end
              group :development do
                gem "rdoc", ">= 2.4.2"
                gem "yard"
              end
              group :test do
                gem "minitest"
-               gem "mocha", "~> 1.0.0", :require => 'mocha/api'
+               gem "rails-dom-testing"
+               gem "mocha", "~> 1.0.0"
                gem "simplecov", "~> 0.9.1", :require => false
                # For running UI tests
                gem "capybara"
                gem "selenium-webdriver"
              end
              local_gemfile = File.join(File.dirname(__FILE__), "Gemfile.local")
              if File.exists?(local_gemfile)
                eval_gemfile local_gemfile
              end
              # Load plugins' Gemfiles
              Dir.glob File.expand_path("../plugins/*/{Gemfile,PluginGemfile}", __FILE__) do |file|
                eval_gemfile file
              end

app/helpers/application_helper.rb +19 -15

              # encoding: utf-8
              #
              # Redmine - project management software
              # Copyright (C) 2006-2015  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 'forwardable'
              require 'cgi'
              module ApplicationHelper
                include Redmine::WikiFormatting::Macros::Definitions
                include Redmine::I18n
                include GravatarHelper::PublicMethods
                include Redmine::Pagination::Helper
                extend Forwardable
                def_delegators :wiki_helper, :wikitoolbar_for, :heads_for_wiki_formatter
                # Return true if user is authorized for controller/action, otherwise false
                def authorize_for(controller, action)
                  User.current.allowed_to?({:controller => controller, :action => action}, @project)
                end
                # Display a link if user is authorized
                #
                # @param [String] name Anchor text (passed to link_to)
                # @param [Hash] options Hash params. This will checked by authorize_for to see if the user is authorized
                # @param [optional, Hash] html_options Options passed to link_to
                # @param [optional, Hash] parameters_for_method_reference Extra parameters for link_to
                def link_to_if_authorized(name, options = {}, html_options = nil, *parameters_for_method_reference)
                  link_to(name, options, html_options, *parameters_for_method_reference) if authorize_for(options[:controller] || params[:controller], options[:action])
                end
                # Displays a link to user's account page if active
                def link_to_user(user, options={})
                  if user.is_a?(User)
                    name = h(user.name(options[:format]))
                    if user.active? || (User.current.admin? && user.logged?)
                      link_to name, user_path(user), :class => user.css_classes
                    else
                      name
                    end
                  else
                    h(user.to_s)
                  end
                end
                # Displays a link to +issue+ with its subject.
                # Examples:
                #
                #   link_to_issue(issue)                        # => Defect #6: This is the subject
                #   link_to_issue(issue, :truncate => 6)        # => Defect #6: This i...
                #   link_to_issue(issue, :subject => false)     # => Defect #6
                #   link_to_issue(issue, :project => true)      # => Foo - Defect #6
                #   link_to_issue(issue, :subject => false, :tracker => false)     # => #6
                #
                def link_to_issue(issue, options={})
                  title = nil
                  subject = nil
                  text = options[:tracker] == false ? "##{issue.id}" : "#{issue.tracker} ##{issue.id}"
                  if options[:subject] == false
                    title = issue.subject.truncate(60)
                  else
                    subject = issue.subject
                    if truncate_length = options[:truncate]
                      subject = subject.truncate(truncate_length)
                    end
                  end
                  only_path = options[:only_path].nil? ? true : options[:only_path]
-                 s = link_to(text, issue_path(issue, :only_path => only_path),
+                 s = link_to(text, issue_url(issue, :only_path => only_path),
                              :class => issue.css_classes, :title => title)
                  s << h(": #{subject}") if subject
                  s = h("#{issue.project} - ") + s if options[:project]
                  s
                end
                # Generates a link to an attachment.
                # Options:
                # * :text - Link text (default to attachment filename)
                # * :download - Force download (default: false)
                def link_to_attachment(attachment, options={})
                  text = options.delete(:text) || attachment.filename
-                 route_method = options.delete(:download) ? :download_named_attachment_path : :named_attachment_path
+                 route_method = options.delete(:download) ? :download_named_attachment_url : :named_attachment_url
                  html_options = options.slice!(:only_path)
+                 options[:only_path] = true unless options.key?(:only_path)
                  url = send(route_method, attachment, attachment.filename, options)
                  link_to text, url, html_options
                end
                # Generates a link to a SCM revision
                # Options:
                # * :text - Link text (default to the formatted revision)
                def link_to_revision(revision, repository, options={})
                  if repository.is_a?(Project)
                    repository = repository.repository
                  end
                  text = options.delete(:text) || format_revision(revision)
                  rev = revision.respond_to?(:identifier) ? revision.identifier : revision
                  link_to(
                      h(text),
                      {:controller => 'repositories', :action => 'revision', :id => repository.project, :repository_id => repository.identifier_param, :rev => rev},
                      :title => l(:label_revision_id, format_revision(revision)),
                      :accesskey => options[:accesskey]
                    )
                end
                # Generates a link to a message
                def link_to_message(message, options={}, html_options = nil)
                  link_to(
                    message.subject.truncate(60),
-                   board_message_path(message.board_id, message.parent_id || message.id, {
+                   board_message_url(message.board_id, message.parent_id || message.id, {
                      :r => (message.parent_id && message.id),
-                     :anchor => (message.parent_id ? "message-#{message.id}" : nil)
+                     :anchor => (message.parent_id ? "message-#{message.id}" : nil),
+                     :only_path => true
                    }.merge(options)),
                    html_options
                  )
                end
                # Generates a link to a project if active
                # Examples:
                #
                #   link_to_project(project)                          # => link to the specified project overview
                #   link_to_project(project, {:only_path => false}, :class => "project") # => 3rd arg adds html options
                #   link_to_project(project, {}, :class => "project") # => html options with default url (project overview)
                #
                def link_to_project(project, options={}, html_options = nil)
                  if project.archived?
                    h(project.name)
                  else
-                   link_to project.name, project_path(project, options), html_options
+                   link_to project.name,
+                     project_url(project, {:only_path => true}.merge(options)),
+                     html_options
                  end
                end
                # Generates a link to a project settings if active
                def link_to_project_settings(project, options={}, html_options=nil)
                  if project.active?
                    link_to project.name, settings_project_path(project, options), html_options
                  elsif project.archived?
                    h(project.name)
                  else
                    link_to project.name, project_path(project, options), html_options
                  end
                end
                # Generates a link to a version
                def link_to_version(version, options = {})
                  return '' unless version && version.is_a?(Version)
                  options = {:title => format_date(version.effective_date)}.merge(options)
                  link_to_if version.visible?, format_version_name(version), version_path(version), options
                end
                # Helper that formats object for html or text rendering
                def format_object(object, html=true, &block)
                  if block_given?
                    object = yield object
                  end
                  case object.class.name
                  when 'Array'
                    object.map {|o| format_object(o, html)}.join(', ').html_safe
                  when 'Time'
                    format_time(object)
                  when 'Date'
                    format_date(object)
                  when 'Fixnum'
                    object.to_s
                  when 'Float'
                    sprintf "%.2f", object
                  when 'User'
                    html ? link_to_user(object) : object.to_s
                  when 'Project'
                    html ? link_to_project(object) : object.to_s
                  when 'Version'
                    html ? link_to_version(object) : object.to_s
                  when 'TrueClass'
                    l(:general_text_Yes)
                  when 'FalseClass'
                    l(:general_text_No)
                  when 'Issue'
                    object.visible? && html ? link_to_issue(object) : "##{object.id}"
                  when 'CustomValue', 'CustomFieldValue'
                    if object.custom_field
                      f = object.custom_field.format.formatted_custom_value(self, object, html)
                      if f.nil? || f.is_a?(String)
                        f
                      else
                        format_object(f, html, &block)
                      end
                    else
                      object.value.to_s
                    end
                  else
                    html ? h(object) : object.to_s
                  end
                end
                def wiki_page_path(page, options={})
                  url_for({:controller => 'wiki', :action => 'show', :project_id => page.project, :id => page.title}.merge(options))
                end
                def thumbnail_tag(attachment)
                  link_to image_tag(thumbnail_path(attachment)),
                    named_attachment_path(attachment, attachment.filename),
                    :title => attachment.filename
                end
                def toggle_link(name, id, options={})
                  onclick = "$('##{id}').toggle(); "
                  onclick << (options[:focus] ? "$('##{options[:focus]}').focus(); " : "this.blur(); ")
                  onclick << "return false;"
                  link_to(name, "#", :onclick => onclick)
                end
                def format_activity_title(text)
                  h(truncate_single_line_raw(text, 100))
                end
                def format_activity_day(date)
                  date == User.current.today ? l(:label_today).titleize : format_date(date)
                end
                def format_activity_description(text)
                  h(text.to_s.truncate(120).gsub(%r{[\r\n]*<(pre|code)>.*$}m, '...')
                     ).gsub(/[\r\n]+/, "<br />").html_safe
                end
                def format_version_name(version)
                  if !version.shared? || version.project == @project
                    h(version)
                  else
                    h("#{version.project} - #{version}")
                  end
                end
                def due_date_distance_in_words(date)
                  if date
                    l((date < Date.today ? :label_roadmap_overdue : :label_roadmap_due_in), distance_of_date_in_words(Date.today, date))
                  end
                end
                # Renders a tree of projects as a nested set of unordered lists
                # The given collection may be a subset of the whole project tree
                # (eg. some intermediate nodes are private and can not be seen)
                def render_project_nested_lists(projects, &block)
                  s = ''
                  if projects.any?
                    ancestors = []
                    original_project = @project
                    projects.sort_by(&:lft).each do |project|
                      # set the project environment to please macros.
                      @project = project
                      if (ancestors.empty? || project.is_descendant_of?(ancestors.last))
                        s << "<ul class='projects #{ ancestors.empty? ? 'root' : nil}'>\n"
                      else
                        ancestors.pop
                        s << "</li>"
                        while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
                          ancestors.pop
                          s << "</ul></li>\n"
                        end
                      end
                      classes = (ancestors.empty? ? 'root' : 'child')
                      s << "<li class='#{classes}'><div class='#{classes}'>"
                      s << h(block_given? ? capture(project, &block) : project.name)
                      s << "</div>\n"
                      ancestors << project
                    end
                    s << ("</li></ul>\n" * ancestors.size)
                    @project = original_project
                  end
                  s.html_safe
                end
                def render_page_hierarchy(pages, node=nil, options={})
                  content = ''
                  if pages[node]
                    content << "<ul class=\"pages-hierarchy\">\n"
                    pages[node].each do |page|
                      content << "<li>"
                      content << link_to(h(page.pretty_title), {:controller => 'wiki', :action => 'show', :project_id => page.project, :id => page.title, :version => nil},
                                         :title => (options[:timestamp] && page.updated_on ? l(:label_updated_time, distance_of_time_in_words(Time.now, page.updated_on)) : nil))
                      content << "\n" + render_page_hierarchy(pages, page.id, options) if pages[page.id]
                      content << "</li>\n"
                    end
                    content << "</ul>\n"
                  end
                  content.html_safe
                end
                # Renders flash messages
                def render_flash_messages
                  s = ''
                  flash.each do |k,v|
                    s << content_tag('div', v.html_safe, :class => "flash #{k}", :id => "flash_#{k}")
                  end
                  s.html_safe
                end
                # Renders tabs and their content
                def render_tabs(tabs, selected=params[:tab])
                  if tabs.any?
                    unless tabs.detect {|tab| tab[:name] == selected}
                      selected = nil
                    end
                    selected ||= tabs.first[:name]
                    render :partial => 'common/tabs', :locals => {:tabs => tabs, :selected_tab => selected}
                  else
                    content_tag 'p', l(:label_no_data), :class => "nodata"
                  end
                end
                # Renders the project quick-jump box
                def render_project_jump_box
                  return unless User.current.logged?
                  projects = User.current.memberships.collect(&:project).compact.select(&:active?).uniq
                  if projects.any?
                    options =
                      ("<option value=''>#{ l(:label_jump_to_a_project) }</option>" +
                       '<option value="" disabled="disabled">---</option>').html_safe
                    options << project_tree_options_for_select(projects, :selected => @project) do |p|
                      { :value => project_path(:id => p, :jump => current_menu_item) }
                    end
                    select_tag('project_quick_jump_box', options, :onchange => 'if (this.value != \'\') { window.location = this.value; }')
                  end
                end
                def project_tree_options_for_select(projects, options = {})
                  s = ''.html_safe
                  if options[:include_blank]
                    s << content_tag('option', '&nbsp;'.html_safe, :value => '')
                  end
                  project_tree(projects) do |project, level|
                    name_prefix = (level > 0 ? '&nbsp;' * 2 * level + '&#187; ' : '').html_safe
                    tag_options = {:value => project.id}
                    if project == options[:selected] || (options[:selected].respond_to?(:include?) && options[:selected].include?(project))
                      tag_options[:selected] = 'selected'
                    else
                      tag_options[:selected] = nil
                    end
                    tag_options.merge!(yield(project)) if block_given?
                    s << content_tag('option', name_prefix + h(project), tag_options)
                  end
                  s.html_safe
                end
                # Yields the given block for each project with its level in the tree
                #
                # Wrapper for Project#project_tree
                def project_tree(projects, &block)
                  Project.project_tree(projects, &block)
                end
                def principals_check_box_tags(name, principals)
                  s = ''
                  principals.each do |principal|
                    s << "<label>#{ check_box_tag name, principal.id, false, :id => nil } #{h principal}</label>\n"
                  end
                  s.html_safe
                end
                # Returns a string for users/groups option tags
                def principals_options_for_select(collection, selected=nil)
                  s = ''
                  if collection.include?(User.current)
                    s << content_tag('option', "<< #{l(:label_me)} >>", :value => User.current.id)
                  end
                  groups = ''
                  collection.sort.each do |element|
                    selected_attribute = ' selected="selected"' if option_value_selected?(element, selected) || element.id.to_s == selected
                    (element.is_a?(Group) ? groups : s) << %(<option value="#{element.id}"#{selected_attribute}>#{h element.name}</option>)
                  end
                  unless groups.empty?
                    s << %(<optgroup label="#{h(l(:label_group_plural))}">#{groups}</optgroup>)
                  end
                  s.html_safe
                end
                def option_tag(name, text, value, selected=nil, options={})
                  content_tag 'option', value, options.merge(:value => value, :selected => (value == selected))
                end
                def truncate_single_line_raw(string, length)
                  string.truncate(length).gsub(%r{[\r\n]+}m, ' ')
                end
                # Truncates at line break after 250 characters or options[:length]
                def truncate_lines(string, options={})
                  length = options[:length] || 250
                  if string.to_s =~ /\A(.{#{length}}.*?)$/m
                    "#{$1}..."
                  else
                    string
                  end
                end
                def anchor(text)
                  text.to_s.gsub(' ', '_')
                end
                def html_hours(text)
                  text.gsub(%r{(\d+)\.(\d+)}, '<span class="hours hours-int">\1</span><span class="hours hours-dec">.\2</span>').html_safe
                end
                def authoring(created, author, options={})
                  l(options[:label] || :label_added_time_by, :author => link_to_user(author), :age => time_tag(created)).html_safe
                end
                def time_tag(time)
                  text = distance_of_time_in_words(Time.now, time)
                  if @project
                    link_to(text, {:controller => 'activities', :action => 'index', :id => @project, :from => User.current.time_to_date(time)}, :title => format_time(time))
                  else
                    content_tag('abbr', text, :title => format_time(time))
                  end
                end
                def syntax_highlight_lines(name, content)
                  lines = []
                  syntax_highlight(name, content).each_line { |line| lines << line }
                  lines
                end
                def syntax_highlight(name, content)
                  Redmine::SyntaxHighlighting.highlight_by_filename(content, name)
                end
                def to_path_param(path)
                  str = path.to_s.split(%r{[/\\]}).select{|p| !p.blank?}.join("/")
                  str.blank? ? nil : str
                end
                def reorder_links(name, url, method = :post)
                  link_to(image_tag('2uparrow.png', :alt => l(:label_sort_highest)),
                          url.merge({"#{name}[move_to]" => 'highest'}),
                          :method => method, :title => l(:label_sort_highest)) +
                  link_to(image_tag('1uparrow.png',   :alt => l(:label_sort_higher)),
                          url.merge({"#{name}[move_to]" => 'higher'}),
                         :method => method, :title => l(:label_sort_higher)) +
                  link_to(image_tag('1downarrow.png', :alt => l(:label_sort_lower)),
                          url.merge({"#{name}[move_to]" => 'lower'}),
                          :method => method, :title => l(:label_sort_lower)) +
                  link_to(image_tag('2downarrow.png', :alt => l(:label_sort_lowest)),
                          url.merge({"#{name}[move_to]" => 'lowest'}),
                         :method => method, :title => l(:label_sort_lowest))
                end
                def breadcrumb(*args)
                  elements = args.flatten
                  elements.any? ? content_tag('p', (args.join(" \xc2\xbb ") + " \xc2\xbb ").html_safe, :class => 'breadcrumb') : nil
                end
                def other_formats_links(&block)
                  concat('<p class="other-formats">'.html_safe + l(:label_export_to))
                  yield Redmine::Views::OtherFormatsBuilder.new(self)
                  concat('</p>'.html_safe)
                end
                def page_header_title
                  if @project.nil? || @project.new_record?
                    h(Setting.app_title)
                  else
                    b = []
                    ancestors = (@project.root? ? [] : @project.ancestors.visible.to_a)
                    if ancestors.any?
                      root = ancestors.shift
                      b << link_to_project(root, {:jump => current_menu_item}, :class => 'root')
                      if ancestors.size > 2
                        b << "\xe2\x80\xa6"
                        ancestors = ancestors[-2, 2]
                      end
                      b += ancestors.collect {|p| link_to_project(p, {:jump => current_menu_item}, :class => 'ancestor') }
                    end
                    b << h(@project)
                    b.join(" \xc2\xbb ").html_safe
                  end
                end
                # Returns a h2 tag and sets the html title with the given arguments
                def title(*args)
                  strings = args.map do |arg|
                    if arg.is_a?(Array) && arg.size >= 2
                      link_to(*arg)
                    else
                      h(arg.to_s)
                    end
                  end
                  html_title args.reverse.map {|s| (s.is_a?(Array) ? s.first : s).to_s}
                  content_tag('h2', strings.join(' &#187; ').html_safe)
                end
                # Sets the html title
                # Returns the html title when called without arguments
                # Current project name and app_title and automatically appended
                # Exemples:
                #   html_title 'Foo', 'Bar'
                #   html_title # => 'Foo - Bar - My Project - Redmine'
                def html_title(*args)
                  if args.empty?
                    title = @html_title || []
                    title << @project.name if @project
                    title << Setting.app_title unless Setting.app_title == title.last
                    title.reject(&:blank?).join(' - ')
                  else
                    @html_title ||= []
                    @html_title += args
                  end
                end
                # Returns the theme, controller name, and action as css classes for the
                # HTML body.
                def body_css_classes
                  css = []
                  if theme = Redmine::Themes.theme(Setting.ui_theme)
                    css << 'theme-' + theme.name
                  end
                  css << 'project-' + @project.identifier if @project && @project.identifier.present?
                  css << 'controller-' + controller_name
                  css << 'action-' + action_name
                  css.join(' ')
                end
                def accesskey(s)
                  @used_accesskeys ||= []
                  key = Redmine::AccessKeys.key_for(s)
                  return nil if @used_accesskeys.include?(key)
                  @used_accesskeys << key
                  key
                end
                # Formats text according to system settings.
                # 2 ways to call this method:
                # * with a String: textilizable(text, options)
                # * with an object and one of its attribute: textilizable(issue, :description, options)
                def textilizable(*args)
                  options = args.last.is_a?(Hash) ? args.pop : {}
                  case args.size
                  when 1
                    obj = options[:object]
                    text = args.shift
                  when 2
                    obj = args.shift
                    attr = args.shift
                    text = obj.send(attr).to_s
                  else
                    raise ArgumentError, 'invalid arguments to textilizable'
                  end
                  return '' if text.blank?
                  project = options[:project] || @project || (obj && obj.respond_to?(:project) ? obj.project : nil)
                  @only_path = only_path = options.delete(:only_path) == false ? false : true
                  text = text.dup
                  macros = catch_macros(text)
                  text = Redmine::WikiFormatting.to_html(Setting.text_formatting, text, :object => obj, :attribute => attr)
                  @parsed_headings = []
                  @heading_anchors = {}
                  @current_section = 0 if options[:edit_section_links]
                  parse_sections(text, project, obj, attr, only_path, options)
                  text = parse_non_pre_blocks(text, obj, macros) do |text|
                    [:parse_inline_attachments, :parse_wiki_links, :parse_redmine_links].each do |method_name|
                      send method_name, text, project, obj, attr, only_path, options
                    end
                  end
                  parse_headings(text, project, obj, attr, only_path, options)
                  if @parsed_headings.any?
                    replace_toc(text, @parsed_headings)
                  end
                  text.html_safe
                end
                def parse_non_pre_blocks(text, obj, macros)
                  s = StringScanner.new(text)
                  tags = []
                  parsed = ''
                  while !s.eos?
                    s.scan(/(.*?)(<(\/)?(pre|code)(.*?)>|\z)/im)
                    text, full_tag, closing, tag = s[1], s[2], s[3], s[4]
                    if tags.empty?
                      yield text
                      inject_macros(text, obj, macros) if macros.any?
                    else
                      inject_macros(text, obj, macros, false) if macros.any?
                    end
                    parsed << text
                    if tag
                      if closing
                        if tags.last == tag.downcase
                          tags.pop
                        end
                      else
                        tags << tag.downcase
                      end
                      parsed << full_tag
                    end
                  end
                  # Close any non closing tags
                  while tag = tags.pop
                    parsed << "</#{tag}>"
                  end
                  parsed
                end
                def parse_inline_attachments(text, project, obj, attr, only_path, options)
                  # when using an image link, try to use an attachment, if possible
                  attachments = options[:attachments] || []
                  attachments += obj.attachments if obj.respond_to?(:attachments)
                  if attachments.present?
                    text.gsub!(/src="([^\/"]+\.(bmp|gif|jpg|jpe|jpeg|png))"(\s+alt="([^"]*)")?/i) do |m|
                      filename, ext, alt, alttext = $1.downcase, $2, $3, $4
                      # search for the picture in attachments
                      if found = Attachment.latest_attach(attachments, filename)
-                       image_url = download_named_attachment_path(found, found.filename, :only_path => only_path)
+                       image_url = download_named_attachment_url(found, found.filename, :only_path => only_path)
                        desc = found.description.to_s.gsub('"', '')
                        if !desc.blank? && alttext.blank?
                          alt = " title=\"#{desc}\" alt=\"#{desc}\""
                        end
                        "src=\"#{image_url}\"#{alt}"
                      else
                        m
                      end
                    end
                  end
                end
                # Wiki links
                #
                # Examples:
                #   [[mypage]]
                #   [[mypage|mytext]]
                # wiki links can refer other project wikis, using project name or identifier:
                #   [[project:]] -> wiki starting page
                #   [[project:|mytext]]
                #   [[project:mypage]]
                #   [[project:mypage|mytext]]
                def parse_wiki_links(text, project, obj, attr, only_path, options)
                  text.gsub!(/(!)?(\[\[([^\]\n\|]+)(\|([^\]\n\|]+))?\]\])/) do |m|
                    link_project = project
                    esc, all, page, title = $1, $2, $3, $5
                    if esc.nil?
                      if page =~ /^([^\:]+)\:(.*)$/
                        identifier, page = $1, $2
                        link_project = Project.find_by_identifier(identifier) || Project.find_by_name(identifier)
                        title ||= identifier if page.blank?
                      end
                      if link_project && link_project.wiki
                        # extract anchor
                        anchor = nil
                        if page =~ /^(.+?)\#(.+)$/
                          page, anchor = $1, $2
                        end
                        anchor = sanitize_anchor_name(anchor) if anchor.present?
                        # check if page exists
                        wiki_page = link_project.wiki.find_page(page)
                        url = if anchor.present? && wiki_page.present? && (obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version)) && obj.page == wiki_page
                          "##{anchor}"
                        else
                          case options[:wiki_links]
                          when :local; "#{page.present? ? Wiki.titleize(page) : ''}.html" + (anchor.present? ? "##{anchor}" : '')
                          when :anchor; "##{page.present? ? Wiki.titleize(page) : title}" + (anchor.present? ? "_#{anchor}" : '') # used for single-file wiki export
                          else
                            wiki_page_id = page.present? ? Wiki.titleize(page) : nil
                            parent = wiki_page.nil? && obj.is_a?(WikiContent) && obj.page && project == link_project ? obj.page.title : nil
                            url_for(:only_path => only_path, :controller => 'wiki', :action => 'show', :project_id => link_project,
                             :id => wiki_page_id, :version => nil, :anchor => anchor, :parent => parent)
                          end
                        end
                        link_to(title.present? ? title.html_safe : h(page), url, :class => ('wiki-page' + (wiki_page ? '' : ' new')))
                      else
                        # project or wiki doesn't exist
                        all
                      end
                    else
                      all
                    end
                  end
                end
                # Redmine links
                #
                # Examples:
                #   Issues:
                #     #52 -> Link to issue #52
                #   Changesets:
                #     r52 -> Link to revision 52
                #     commit:a85130f -> Link to scmid starting with a85130f
                #   Documents:
                #     document#17 -> Link to document with id 17
                #     document:Greetings -> Link to the document with title "Greetings"
                #     document:"Some document" -> Link to the document with title "Some document"
                #   Versions:
                #     version#3 -> Link to version with id 3
                #     version:1.0.0 -> Link to version named "1.0.0"
                #     version:"1.0 beta 2" -> Link to version named "1.0 beta 2"
                #   Attachments:
                #     attachment:file.zip -> Link to the attachment of the current object named file.zip
                #   Source files:
                #     source:some/file -> Link to the file located at /some/file in the project's repository
                #     source:some/file@52 -> Link to the file's revision 52
                #     source:some/file#L120 -> Link to line 120 of the file
                #     source:some/file@52#L120 -> Link to line 120 of the file's revision 52
                #     export:some/file -> Force the download of the file
                #   Forum messages:
                #     message#1218 -> Link to message with id 1218
                #  Projects:
                #     project:someproject -> Link to project named "someproject"
                #     project#3 -> Link to project with id 3
                #
                #   Links can refer other objects from other projects, using project identifier:
                #     identifier:r52
                #     identifier:document:"Some document"
                #     identifier:version:1.0.0
                #     identifier:source:some/file
                def parse_redmine_links(text, default_project, obj, attr, only_path, options)
                  text.gsub!(%r{<a( [^>]+?)?>(.*?)</a>|([\s\(,\-\[\>]|^)(!)?(([a-z0-9\-_]+):)?(attachment|document|version|forum|news|message|project|commit|source|export)?(((#)|((([a-z0-9\-_]+)\|)?(r)))((\d+)((#note)?-(\d+))?)|(:)([^"\s<>][^\s<>]*?|"[^"]+?"))(?=(?=[[:punct:]][^A-Za-z0-9_/])|,|\s|\]|<|$)}) do |m|
                    tag_content, leading, esc, project_prefix, project_identifier, prefix, repo_prefix, repo_identifier, sep, identifier, comment_suffix, comment_id = $1, $3, $4, $5, $6, $7, $12, $13, $10 || $14 || $20, $16 || $21, $17, $19
                    if tag_content
                      $&
                    else
                      link = nil
                      project = default_project
                      if project_identifier
                        project = Project.visible.find_by_identifier(project_identifier)
                      end
                      if esc.nil?
                        if prefix.nil? && sep == 'r'
                          if project
                            repository = nil
                            if repo_identifier
                              repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                            else
                              repository = project.repository
                            end
                            # project.changesets.visible raises an SQL error because of a double join on repositories
                            if repository &&
                                 (changeset = Changeset.visible.
                                                  find_by_repository_id_and_revision(repository.id, identifier))
                              link = link_to(h("#{project_prefix}#{repo_prefix}r#{identifier}"),
                                             {:only_path => only_path, :controller => 'repositories',
                                              :action => 'revision', :id => project,
                                              :repository_id => repository.identifier_param,
                                              :rev => changeset.revision},
                                             :class => 'changeset',
                                             :title => truncate_single_line_raw(changeset.comments, 100))
                            end
                          end
                        elsif sep == '#'
                          oid = identifier.to_i
                          case prefix
                          when nil
                            if oid.to_s == identifier &&
                              issue = Issue.visible.find_by_id(oid)
                              anchor = comment_id ? "note-#{comment_id}" : nil
                              link = link_to("##{oid}#{comment_suffix}",
-                                            issue_path(issue, :only_path => only_path, :anchor => anchor),
+                                            issue_url(issue, :only_path => only_path, :anchor => anchor),
                                             :class => issue.css_classes,
                                             :title => "#{issue.subject.truncate(100)} (#{issue.status.name})")
                            end
                          when 'document'
                            if document = Document.visible.find_by_id(oid)
-                             link = link_to(document.title, document_path(document, :only_path => only_path), :class => 'document')
+                             link = link_to(document.title, document_url(document, :only_path => only_path), :class => 'document')
                            end
                          when 'version'
                            if version = Version.visible.find_by_id(oid)
-                             link = link_to(version.name, version_path(version, :only_path => only_path), :class => 'version')
+                             link = link_to(version.name, version_url(version, :only_path => only_path), :class => 'version')
                            end
                          when 'message'
                            if message = Message.visible.find_by_id(oid)
                              link = link_to_message(message, {:only_path => only_path}, :class => 'message')
                            end
                          when 'forum'
                            if board = Board.visible.find_by_id(oid)
-                             link = link_to(board.name, project_board_path(board.project, board, :only_path => only_path), :class => 'board')
+                             link = link_to(board.name, project_board_url(board.project, board, :only_path => only_path), :class => 'board')
                            end
                          when 'news'
                            if news = News.visible.find_by_id(oid)
-                             link = link_to(news.title, news_path(news, :only_path => only_path), :class => 'news')
+                             link = link_to(news.title, news_url(news, :only_path => only_path), :class => 'news')
                            end
                          when 'project'
                            if p = Project.visible.find_by_id(oid)
                              link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                            end
                          end
                        elsif sep == ':'
                          # removes the double quotes if any
                          name = identifier.gsub(%r{^"(.*)"$}, "\\1")
                          name = CGI.unescapeHTML(name)
                          case prefix
                          when 'document'
                            if project && document = project.documents.visible.find_by_title(name)
-                             link = link_to(document.title, document_path(document, :only_path => only_path), :class => 'document')
+                             link = link_to(document.title, document_url(document, :only_path => only_path), :class => 'document')
                            end
                          when 'version'
                            if project && version = project.versions.visible.find_by_name(name)
-                             link = link_to(version.name, version_path(version, :only_path => only_path), :class => 'version')
+                             link = link_to(version.name, version_url(version, :only_path => only_path), :class => 'version')
                            end
                          when 'forum'
                            if project && board = project.boards.visible.find_by_name(name)
-                             link = link_to(board.name, project_board_path(board.project, board, :only_path => only_path), :class => 'board')
+                             link = link_to(board.name, project_board_url(board.project, board, :only_path => only_path), :class => 'board')
                            end
                          when 'news'
                            if project && news = project.news.visible.find_by_title(name)
-                             link = link_to(news.title, news_path(news, :only_path => only_path), :class => 'news')
+                             link = link_to(news.title, news_url(news, :only_path => only_path), :class => 'news')
                            end
                          when 'commit', 'source', 'export'
                            if project
                              repository = nil
                              if name =~ %r{^(([a-z0-9\-_]+)\|)(.+)$}
                                repo_prefix, repo_identifier, name = $1, $2, $3
                                repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                              else
                                repository = project.repository
                              end
                              if prefix == 'commit'
                                if repository && (changeset = Changeset.visible.where("repository_id = ? AND scmid LIKE ?", repository.id, "#{name}%").first)
                                  link = link_to h("#{project_prefix}#{repo_prefix}#{name}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :repository_id => repository.identifier_param, :rev => changeset.identifier},
                                                               :class => 'changeset',
                                                               :title => truncate_single_line_raw(changeset.comments, 100)
                                end
                              else
                                if repository && User.current.allowed_to?(:browse_repository, project)
                                  name =~ %r{^[/\\]*(.*?)(@([^/\\@]+?))?(#(L\d+))?$}
                                  path, rev, anchor = $1, $3, $5
                                  link = link_to h("#{project_prefix}#{prefix}:#{repo_prefix}#{name}"), {:only_path => only_path, :controller => 'repositories', :action => (prefix == 'export' ? 'raw' : 'entry'), :id => project, :repository_id => repository.identifier_param,
                                                                          :path => to_path_param(path),
                                                                          :rev => rev,
                                                                          :anchor => anchor},
                                                                         :class => (prefix == 'export' ? 'source download' : 'source')
                                end
                              end
                              repo_prefix = nil
                            end
                          when 'attachment'
                            attachments = options[:attachments] || []
                            attachments += obj.attachments if obj.respond_to?(:attachments)
                            if attachments && attachment = Attachment.latest_attach(attachments, name)
                              link = link_to_attachment(attachment, :only_path => only_path, :download => true, :class => 'attachment')
                            end
                          when 'project'
                            if p = Project.visible.where("identifier = :s OR LOWER(name) = :s", :s => name.downcase).first
                              link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                            end
                          end
                        end
                      end
                      (leading + (link || "#{project_prefix}#{prefix}#{repo_prefix}#{sep}#{identifier}#{comment_suffix}"))
                    end
                  end
                end
                HEADING_RE = /(<h(\d)( [^>]+)?>(.+?)<\/h(\d)>)/i unless const_defined?(:HEADING_RE)
                def parse_sections(text, project, obj, attr, only_path, options)
                  return unless options[:edit_section_links]
                  text.gsub!(HEADING_RE) do
                    heading = $1
                    @current_section += 1
                    if @current_section > 1
                      content_tag('div',
                        link_to(image_tag('edit.png'), options[:edit_section_links].merge(:section => @current_section)),
                        :class => 'contextual',
                        :title => l(:button_edit_section),
                        :id => "section-#{@current_section}") + heading.html_safe
                    else
                      heading
                    end
                  end
                end
                # Headings and TOC
                # Adds ids and links to headings unless options[:headings] is set to false
                def parse_headings(text, project, obj, attr, only_path, options)
                  return if options[:headings] == false
                  text.gsub!(HEADING_RE) do
                    level, attrs, content = $2.to_i, $3, $4
                    item = strip_tags(content).strip
                    anchor = sanitize_anchor_name(item)
                    # used for single-file wiki export
                    anchor = "#{obj.page.title}_#{anchor}" if options[:wiki_links] == :anchor && (obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version))
                    @heading_anchors[anchor] ||= 0
                    idx = (@heading_anchors[anchor] += 1)
                    if idx > 1
                      anchor = "#{anchor}-#{idx}"
                    end
                    @parsed_headings << [level, anchor, item]
                    "<a name=\"#{anchor}\"></a>\n<h#{level} #{attrs}>#{content}<a href=\"##{anchor}\" class=\"wiki-anchor\">&para;</a></h#{level}>"
                  end
                end
                MACROS_RE = /(
                              (!)?                        # escaping
                              (
                              \{\{                        # opening tag
                              ([\w]+)                     # macro name
                              (\(([^\n\r]*?)\))?          # optional arguments
                              ([\n\r].*?[\n\r])?          # optional block of text
                              \}\}                        # closing tag
                              )
                             )/mx unless const_defined?(:MACROS_RE)
                MACRO_SUB_RE = /(
                                \{\{
                                macro\((\d+)\)
                                \}\}
                                )/x unless const_defined?(:MACRO_SUB_RE)
                # Extracts macros from text
                def catch_macros(text)
                  macros = {}
                  text.gsub!(MACROS_RE) do
                    all, macro = $1, $4.downcase
                    if macro_exists?(macro) || all =~ MACRO_SUB_RE
                      index = macros.size
                      macros[index] = all
                      "{{macro(#{index})}}"
                    else
                      all
                    end
                  end
                  macros
                end
                # Executes and replaces macros in text
                def inject_macros(text, obj, macros, execute=true)
                  text.gsub!(MACRO_SUB_RE) do
                    all, index = $1, $2.to_i
                    orig = macros.delete(index)
                    if execute && orig && orig =~ MACROS_RE
                      esc, all, macro, args, block = $2, $3, $4.downcase, $6.to_s, $7.try(:strip)
                      if esc.nil?
                        h(exec_macro(macro, obj, args, block) || all)
                      else
                        h(all)
                      end
                    elsif orig
                      h(orig)
                    else
                      h(all)
                    end
                  end
                end
                TOC_RE = /<p>\{\{((<|&lt;)|(>|&gt;))?toc\}\}<\/p>/i unless const_defined?(:TOC_RE)
                # Renders the TOC with given headings
                def replace_toc(text, headings)
                  text.gsub!(TOC_RE) do
                    left_align, right_align = $2, $3
                    # Keep only the 4 first levels
                    headings = headings.select{|level, anchor, item| level <= 4}
                    if headings.empty?
                      ''
                    else
                      div_class = 'toc'
                      div_class << ' right' if right_align
                      div_class << ' left' if left_align
                      out = "<ul class=\"#{div_class}\"><li>"
                      root = headings.map(&:first).min
                      current = root
                      started = false
                      headings.each do |level, anchor, item|
                        if level > current
                          out << '<ul><li>' * (level - current)
                        elsif level < current
                          out << "</li></ul>\n" * (current - level) + "</li><li>"
                        elsif started
                          out << '</li><li>'
                        end
                        out << "<a href=\"##{anchor}\">#{item}</a>"
                        current = level
                        started = true
                      end
                      out << '</li></ul>' * (current - root)
                      out << '</li></ul>'
                    end
                  end
                end
                # Same as Rails' simple_format helper without using paragraphs
                def simple_format_without_paragraph(text)
                  text.to_s.
                    gsub(/\r\n?/, "\n").                    # \r\n and \r -> \n
                    gsub(/\n\n+/, "<br /><br />").          # 2+ newline  -> 2 br
                    gsub(/([^\n]\n)(?=[^\n])/, '\1<br />'). # 1 newline   -> br
                    html_safe
                end
                def lang_options_for_select(blank=true)
                  (blank ? [["(auto)", ""]] : []) + languages_options
                end
                def labelled_form_for(*args, &proc)
                  args << {} unless args.last.is_a?(Hash)
                  options = args.last
                  if args.first.is_a?(Symbol)
                    options.merge!(:as => args.shift)
                  end
                  options.merge!({:builder => Redmine::Views::LabelledFormBuilder})
                  form_for(*args, &proc)
                end
                def labelled_fields_for(*args, &proc)
                  args << {} unless args.last.is_a?(Hash)
                  options = args.last
                  options.merge!({:builder => Redmine::Views::LabelledFormBuilder})
                  fields_for(*args, &proc)
                end
                def error_messages_for(*objects)
                  html = ""
                  objects = objects.map {|o| o.is_a?(String) ? instance_variable_get("@#{o}") : o}.compact
                  errors = objects.map {|o| o.errors.full_messages}.flatten
                  if errors.any?
                    html << "<div id='errorExplanation'><ul>\n"
                    errors.each do |error|
                      html << "<li>#{h error}</li>\n"
                    end
                    html << "</ul></div>\n"
                  end
                  html.html_safe
                end
                def delete_link(url, options={})
                  options = {
                    :method => :delete,
                    :data => {:confirm => l(:text_are_you_sure)},
                    :class => 'icon icon-del'
                  }.merge(options)
                  link_to l(:button_delete), url, options
                end
                def preview_link(url, form, target='preview', options={})
                  content_tag 'a', l(:label_preview), {
                      :href => "#",
                      :onclick => %|submitPreview("#{escape_javascript url_for(url)}", "#{escape_javascript form}", "#{escape_javascript target}"); return false;|,
                      :accesskey => accesskey(:preview)
                    }.merge(options)
                end
                def link_to_function(name, function, html_options={})
                  content_tag(:a, name, {:href => '#', :onclick => "#{function}; return false;"}.merge(html_options))
                end
                # Helper to render JSON in views
                def raw_json(arg)
                  arg.to_json.to_s.gsub('/', '\/').html_safe
                end
                def back_url
                  url = params[:back_url]
                  if url.nil? && referer = request.env['HTTP_REFERER']
                    url = CGI.unescape(referer.to_s)
                  end
                  url
                end
                def back_url_hidden_field_tag
                  url = back_url
                  hidden_field_tag('back_url', url, :id => nil) unless url.blank?
                end
                def check_all_links(form_name)
                  link_to_function(l(:button_check_all), "checkAll('#{form_name}', true)") +
                  " | ".html_safe +
                  link_to_function(l(:button_uncheck_all), "checkAll('#{form_name}', false)")
                end
                def toggle_checkboxes_link(selector)
                  link_to_function image_tag('toggle_check.png'),
                    "toggleCheckboxesBySelector('#{selector}')",
                    :title => "#{l(:button_check_all)} / #{l(:button_uncheck_all)}"
                end
                def progress_bar(pcts, options={})
                  pcts = [pcts, pcts] unless pcts.is_a?(Array)
                  pcts = pcts.collect(&:round)
                  pcts[1] = pcts[1] - pcts[0]
                  pcts << (100 - pcts[1] - pcts[0])
                  width = options[:width] || '100px;'
                  legend = options[:legend] || ''
                  content_tag('table',
                    content_tag('tr',
                      (pcts[0] > 0 ? content_tag('td', '', :style => "width: #{pcts[0]}%;", :class => 'closed') : ''.html_safe) +
                      (pcts[1] > 0 ? content_tag('td', '', :style => "width: #{pcts[1]}%;", :class => 'done') : ''.html_safe) +
                      (pcts[2] > 0 ? content_tag('td', '', :style => "width: #{pcts[2]}%;", :class => 'todo') : ''.html_safe)
                    ), :class => "progress progress-#{pcts[0]}", :style => "width: #{width};").html_safe +
                    content_tag('p', legend, :class => 'percent').html_safe
                end
                def checked_image(checked=true)
                  if checked
                    image_tag 'toggle_check.png'
                  end
                end
                def context_menu(url)
                  unless @context_menu_included
                    content_for :header_tags do
                      javascript_include_tag('context_menu') +
                        stylesheet_link_tag('context_menu')
                    end
                    if l(:direction) == 'rtl'
                      content_for :header_tags do
                        stylesheet_link_tag('context_menu_rtl')
                      end
                    end
                    @context_menu_included = true
                  end
                  javascript_tag "contextMenuInit('#{ url_for(url) }')"
                end
                def calendar_for(field_id)
                  include_calendar_headers_tags
                  javascript_tag("$(function() { $('##{field_id}').datepicker(datepickerOptions); });")
                end
                def include_calendar_headers_tags
                  unless @calendar_headers_tags_included
                    tags = ''.html_safe
                    @calendar_headers_tags_included = true
                    content_for :header_tags do
                      start_of_week = Setting.start_of_week
                      start_of_week = l(:general_first_day_of_week, :default => '1') if start_of_week.blank?
                      # Redmine uses 1..7 (monday..sunday) in settings and locales
                      # JQuery uses 0..6 (sunday..saturday), 7 needs to be changed to 0
                      start_of_week = start_of_week.to_i % 7
                      tags << javascript_tag(
                                 "var datepickerOptions={dateFormat: 'yy-mm-dd', firstDay: #{start_of_week}, " +
                                   "showOn: 'button', buttonImageOnly: true, buttonImage: '" +
                                   path_to_image('/images/calendar.png') +
                                   "', showButtonPanel: true, showWeek: true, showOtherMonths: true, " +
                                   "selectOtherMonths: true, changeMonth: true, changeYear: true, " +
                                   "beforeShow: beforeShowDatePicker};")
                      jquery_locale = l('jquery.locale', :default => current_language.to_s)
                      unless jquery_locale == 'en'
                        tags << javascript_include_tag("i18n/datepicker-#{jquery_locale}.js")
                      end
                      tags
                    end
                  end
                end
                # Overrides Rails' stylesheet_link_tag with themes and plugins support.
                # Examples:
                #   stylesheet_link_tag('styles') # => picks styles.css from the current theme or defaults
                #   stylesheet_link_tag('styles', :plugin => 'foo) # => picks styles.css from plugin's assets
                #
                def stylesheet_link_tag(*sources)
                  options = sources.last.is_a?(Hash) ? sources.pop : {}
                  plugin = options.delete(:plugin)
                  sources = sources.map do |source|
                    if plugin
                      "/plugin_assets/#{plugin}/stylesheets/#{source}"
                    elsif current_theme && current_theme.stylesheets.include?(source)
                      current_theme.stylesheet_path(source)
                    else
                      source
                    end
                  end
                  super *sources, options
                end
                # Overrides Rails' image_tag with themes and plugins support.
                # Examples:
                #   image_tag('image.png') # => picks image.png from the current theme or defaults
                #   image_tag('image.png', :plugin => 'foo) # => picks image.png from plugin's assets
                #
                def image_tag(source, options={})
                  if plugin = options.delete(:plugin)
                    source = "/plugin_assets/#{plugin}/images/#{source}"
                  elsif current_theme && current_theme.images.include?(source)
                    source = current_theme.image_path(source)
                  end
                  super source, options
                end
                # Overrides Rails' javascript_include_tag with plugins support
                # Examples:
                #   javascript_include_tag('scripts') # => picks scripts.js from defaults
                #   javascript_include_tag('scripts', :plugin => 'foo) # => picks scripts.js from plugin's assets
                #
                def javascript_include_tag(*sources)
                  options = sources.last.is_a?(Hash) ? sources.pop : {}
                  if plugin = options.delete(:plugin)
                    sources = sources.map do |source|
                      if plugin
                        "/plugin_assets/#{plugin}/javascripts/#{source}"
                      else
                        source
                      end
                    end
                  end
                  super *sources, options
                end
                def sidebar_content?
                  content_for?(:sidebar) || view_layouts_base_sidebar_hook_response.present?
                end
                def view_layouts_base_sidebar_hook_response
                  @view_layouts_base_sidebar_hook_response ||= call_hook(:view_layouts_base_sidebar)
                end
                def email_delivery_enabled?
                  !!ActionMailer::Base.perform_deliveries
                end
                # Returns the avatar image tag for the given +user+ if avatars are enabled
                # +user+ can be a User or a string that will be scanned for an email address (eg. 'joe <joe@foo.bar>')
                def avatar(user, options = { })
                  if Setting.gravatar_enabled?
                    options.merge!({:ssl => (request && request.ssl?), :default => Setting.gravatar_default})
                    email = nil
                    if user.respond_to?(:mail)
                      email = user.mail
                    elsif user.to_s =~ %r{<(.+?)>}
                      email = $1
                    end
                    return gravatar(email.to_s.downcase, options) unless email.blank? rescue nil
                  else
                    ''
                  end
                end
                def sanitize_anchor_name(anchor)
                  anchor.gsub(%r{[^\s\-\p{Word}]}, '').gsub(%r{\s+(\-+\s*)?}, '-')
                end
                # Returns the javascript tags that are included in the html layout head
                def javascript_heads
                  tags = javascript_include_tag('jquery-1.11.1-ui-1.11.0-ujs-3.1.1', 'application')
                  unless User.current.pref.warn_on_leaving_unsaved == '0'
                    tags << "\n".html_safe + javascript_tag("$(window).load(function(){ warnLeavingUnsaved('#{escape_javascript l(:text_warn_on_leaving_unsaved)}'); });")
                  end
                  tags
                end
                def favicon
                  "<link rel='shortcut icon' href='#{favicon_path}' />".html_safe
                end
                # Returns the path to the favicon
                def favicon_path
                  icon = (current_theme && current_theme.favicon?) ? current_theme.favicon_path : '/favicon.ico'
                  image_path(icon)
                end
                # Returns the full URL to the favicon
                def favicon_url
                  # TODO: use #image_url introduced in Rails4
                  path = favicon_path
                  base = url_for(:controller => 'welcome', :action => 'index', :only_path => false)
                  base.sub(%r{/+$},'') + '/' + path.sub(%r{^/+},'')
                end
                def robot_exclusion_tag
                  '<meta name="robots" content="noindex,follow,noarchive" />'.html_safe
                end
                # Returns true if arg is expected in the API response
                def include_in_api_response?(arg)
                  unless @included_in_api_response
                    param = params[:include]
                    @included_in_api_response = param.is_a?(Array) ? param.collect(&:to_s) : param.to_s.split(',')
                    @included_in_api_response.collect!(&:strip)
                  end
                  @included_in_api_response.include?(arg.to_s)
                end
                # Returns options or nil if nometa param or X-Redmine-Nometa header
                # was set in the request
                def api_meta(options)
                  if params[:nometa].present? || request.headers['X-Redmine-Nometa']
                    # compatibility mode for activeresource clients that raise
                    # an error when deserializing an array with attributes
                    nil
                  else
                    options
                  end
                end
                private
                def wiki_helper
                  helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
                  extend helper
                  return self
                end
                def link_to_content_update(text, url_params = {}, html_options = {})
                  link_to(text, url_params, html_options)
                end
              end

app/models/issue.rb +1 -2

              # Redmine - project management software
              # Copyright (C) 2006-2015  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.
              class Issue < ActiveRecord::Base
                include Redmine::SafeAttributes
                include Redmine::Utils::DateCalculation
                include Redmine::I18n
                before_save :set_parent_id
                include Redmine::NestedSet::IssueNestedSet
                belongs_to :project
                belongs_to :tracker
                belongs_to :status, :class_name => 'IssueStatus'
                belongs_to :author, :class_name => 'User'
                belongs_to :assigned_to, :class_name => 'Principal'
                belongs_to :fixed_version, :class_name => 'Version'
                belongs_to :priority, :class_name => 'IssuePriority'
                belongs_to :category, :class_name => 'IssueCategory'
                has_many :journals, :as => :journalized, :dependent => :destroy
                has_many :visible_journals,
                  lambda {where(["(#{Journal.table_name}.private_notes = ? OR (#{Project.allowed_to_condition(User.current, :view_private_notes)}))", false])},
                  :class_name => 'Journal',
                  :as => :journalized
                has_many :time_entries, :dependent => :destroy
                has_and_belongs_to_many :changesets, lambda {order("#{Changeset.table_name}.committed_on ASC, #{Changeset.table_name}.id ASC")}
                has_many :relations_from, :class_name => 'IssueRelation', :foreign_key => 'issue_from_id', :dependent => :delete_all
                has_many :relations_to, :class_name => 'IssueRelation', :foreign_key => 'issue_to_id', :dependent => :delete_all
                acts_as_attachable :after_add => :attachment_added, :after_remove => :attachment_removed
                acts_as_customizable
                acts_as_watchable
                acts_as_searchable :columns => ['subject', "#{table_name}.description"],
                                   :preload => [:project, :status, :tracker],
                                   :scope => lambda {|options| options[:open_issues] ? self.open : self.all}
                acts_as_event :title => Proc.new {|o| "#{o.tracker.name} ##{o.id} (#{o.status}): #{o.subject}"},
                              :url => Proc.new {|o| {:controller => 'issues', :action => 'show', :id => o.id}},
                              :type => Proc.new {|o| 'issue' + (o.closed? ? ' closed' : '') }
                acts_as_activity_provider :scope => preload(:project, :author, :tracker),
                                          :author_key => :author_id
                DONE_RATIO_OPTIONS = %w(issue_field issue_status)
                attr_reader :current_journal
                delegate :notes, :notes=, :private_notes, :private_notes=, :to => :current_journal, :allow_nil => true
                validates_presence_of :subject, :project, :tracker
                validates_presence_of :priority, :if => Proc.new {|issue| issue.new_record? || issue.priority_id_changed?}
                validates_presence_of :status, :if => Proc.new {|issue| issue.new_record? || issue.status_id_changed?}
                validates_presence_of :author, :if => Proc.new {|issue| issue.new_record? || issue.author_id_changed?}
                validates_length_of :subject, :maximum => 255
                validates_inclusion_of :done_ratio, :in => 0..100
                validates :estimated_hours, :numericality => {:greater_than_or_equal_to => 0, :allow_nil => true, :message => :invalid}
                validates :start_date, :date => true
                validates :due_date, :date => true
                validate :validate_issue, :validate_required_fields
                attr_protected :id
                scope :visible, lambda {|*args|
-                 includes(:project).
-                 references(:project).
+                 joins(:project).
                  where(Issue.visible_condition(args.shift || User.current, *args))
                }
                scope :open, lambda {|*args|
                  is_closed = args.size > 0 ? !args.first : false
                  joins(:status).
                  where("#{IssueStatus.table_name}.is_closed = ?", is_closed)
                }
                scope :recently_updated, lambda { order("#{Issue.table_name}.updated_on DESC") }
                scope :on_active_project, lambda {
                  joins(:project).
                  where("#{Project.table_name}.status = ?", Project::STATUS_ACTIVE)
                }
                scope :fixed_version, lambda {|versions|
                  ids = [versions].flatten.compact.map {|v| v.is_a?(Version) ? v.id : v}
                  ids.any? ? where(:fixed_version_id => ids) : where('1=0')
                }
                before_create :default_assign
                before_save :close_duplicates, :update_done_ratio_from_issue_status,
                            :force_updated_on_change, :update_closed_on, :set_assigned_to_was
                after_save {|issue| issue.send :after_project_change if !issue.id_changed? && issue.project_id_changed?}
                after_save :reschedule_following_issues, :update_nested_set_attributes,
                           :update_parent_attributes, :create_journal
                # Should be after_create but would be called before previous after_save callbacks
                after_save :after_create_from_copy
                after_destroy :update_parent_attributes
                after_create :send_notification
                # Keep it at the end of after_save callbacks
                after_save :clear_assigned_to_was
                # Returns a SQL conditions string used to find all issues visible by the specified user
                def self.visible_condition(user, options={})
                  Project.allowed_to_condition(user, :view_issues, options) do |role, user|
                    if user.id && user.logged?
                      case role.issues_visibility
                      when 'all'
                        nil
                      when 'default'
                        user_ids = [user.id] + user.groups.map(&:id).compact
                        "(#{table_name}.is_private = #{connection.quoted_false} OR #{table_name}.author_id = #{user.id} OR #{table_name}.assigned_to_id IN (#{user_ids.join(',')}))"
                      when 'own'
                        user_ids = [user.id] + user.groups.map(&:id).compact
                        "(#{table_name}.author_id = #{user.id} OR #{table_name}.assigned_to_id IN (#{user_ids.join(',')}))"
                      else
                        '1=0'
                      end
                    else
                      "(#{table_name}.is_private = #{connection.quoted_false})"
                    end
                  end
                end
                # Returns true if usr or current user is allowed to view the issue
                def visible?(usr=nil)
                  (usr || User.current).allowed_to?(:view_issues, self.project) do |role, user|
                    if user.logged?
                      case role.issues_visibility
                      when 'all'
                        true
                      when 'default'
                        !self.is_private? || (self.author == user || user.is_or_belongs_to?(assigned_to))
                      when 'own'
                        self.author == user || user.is_or_belongs_to?(assigned_to)
                      else
                        false
                      end
                    else
                      !self.is_private?
                    end
                  end
                end
                # Returns true if user or current user is allowed to edit or add a note to the issue
                def editable?(user=User.current)
                  user.allowed_to?(:edit_issues, project) || user.allowed_to?(:add_issue_notes, project)
                end
                def initialize(attributes=nil, *args)
                  super
                  if new_record?
                    # set default values for new records only
                    self.priority ||= IssuePriority.default
                    self.watcher_user_ids = []
                  end
                end
                def create_or_update
                  super
                ensure
                  @status_was = nil
                end
                private :create_or_update
                # AR#Persistence#destroy would raise and RecordNotFound exception
                # if the issue was already deleted or updated (non matching lock_version).
                # This is a problem when bulk deleting issues or deleting a project
                # (because an issue may already be deleted if its parent was deleted
                # first).
                # The issue is reloaded by the nested_set before being deleted so
                # the lock_version condition should not be an issue but we handle it.
                def destroy
                  super
                rescue ActiveRecord::StaleObjectError, ActiveRecord::RecordNotFound
                  # Stale or already deleted
                  begin
                    reload
                  rescue ActiveRecord::RecordNotFound
                    # The issue was actually already deleted
                    @destroyed = true
                    return freeze
                  end
                  # The issue was stale, retry to destroy
                  super
                end
                alias :base_reload :reload
                def reload(*args)
                  @workflow_rule_by_attribute = nil
                  @assignable_versions = nil
                  @relations = nil
                  @spent_hours = nil
                  base_reload(*args)
                end
                # Overrides Redmine::Acts::Customizable::InstanceMethods#available_custom_fields
                def available_custom_fields
                  (project && tracker) ? (project.all_issue_custom_fields & tracker.custom_fields) : []
                end
                def visible_custom_field_values(user=nil)
                  user_real = user || User.current
                  custom_field_values.select do |value|
                    value.custom_field.visible_by?(project, user_real)
                  end
                end
                # Copies attributes from another issue, arg can be an id or an Issue
                def copy_from(arg, options={})
                  issue = arg.is_a?(Issue) ? arg : Issue.visible.find(arg)
                  self.attributes = issue.attributes.dup.except("id", "root_id", "parent_id", "lft", "rgt", "created_on", "updated_on")
                  self.custom_field_values = issue.custom_field_values.inject({}) {|h,v| h[v.custom_field_id] = v.value; h}
                  self.status = issue.status
                  self.author = User.current
                  unless options[:attachments] == false
                    self.attachments = issue.attachments.map do |attachement|
                      attachement.copy(:container => self)
                    end
                  end
                  @copied_from = issue
                  @copy_options = options
                  self
                end
                # Returns an unsaved copy of the issue
                def copy(attributes=nil, copy_options={})
                  copy = self.class.new.copy_from(self, copy_options)
                  copy.attributes = attributes if attributes
                  copy
                end
                # Returns true if the issue is a copy
                def copy?
                  @copied_from.present?
                end
                def status_id=(status_id)
                  if status_id.to_s != self.status_id.to_s
                    self.status = (status_id.present? ? IssueStatus.find_by_id(status_id) : nil)
                  end
                  self.status_id
                end
                # Sets the status.
                def status=(status)
                  if status != self.status
                    @workflow_rule_by_attribute = nil
                  end
                  association(:status).writer(status)
                end
                def priority_id=(pid)
                  self.priority = nil
                  write_attribute(:priority_id, pid)
                end
                def category_id=(cid)
                  self.category = nil
                  write_attribute(:category_id, cid)
                end
                def fixed_version_id=(vid)
                  self.fixed_version = nil
                  write_attribute(:fixed_version_id, vid)
                end
                def tracker_id=(tracker_id)
                  if tracker_id.to_s != self.tracker_id.to_s
                    self.tracker = (tracker_id.present? ? Tracker.find_by_id(tracker_id) : nil)
                  end
                  self.tracker_id
                end
                # Sets the tracker.
                # This will set the status to the default status of the new tracker if:
                # * the status was the default for the previous tracker
                # * or if the status was not part of the new tracker statuses
                # * or the status was nil
                def tracker=(tracker)
                  if tracker != self.tracker
                    if status == default_status
                      self.status = nil
                    elsif status && tracker && !tracker.issue_status_ids.include?(status.id)
                      self.status = nil
                    end
                    @custom_field_values = nil
                    @workflow_rule_by_attribute = nil
                  end
                  association(:tracker).writer(tracker)
                  self.status ||= default_status
                  self.tracker
                end
                def project_id=(project_id)
                  if project_id.to_s != self.project_id.to_s
                    self.project = (project_id.present? ? Project.find_by_id(project_id) : nil)
                  end
                  self.project_id
                end
                # Sets the project.
                # Unless keep_tracker argument is set to true, this will change the tracker
                # to the first tracker of the new project if the previous tracker is not part
                # of the new project trackers.
                # This will clear the fixed_version is it's no longer valid for the new project.
                # This will clear the parent issue if it's no longer valid for the new project.
                # This will set the category to the category with the same name in the new
                # project if it exists, or clear it if it doesn't.
                def project=(project, keep_tracker=false)
                  project_was = self.project
                  association(:project).writer(project)
                  if project_was && project && project_was != project
                    @assignable_versions = nil
                    unless keep_tracker || project.trackers.include?(tracker)
                      self.tracker = project.trackers.first
                    end
                    # Reassign to the category with same name if any
                    if category
                      self.category = project.issue_categories.find_by_name(category.name)
                    end
                    # Keep the fixed_version if it's still valid in the new_project
                    if fixed_version && fixed_version.project != project && !project.shared_versions.include?(fixed_version)
                      self.fixed_version = nil
                    end
                    # Clear the parent task if it's no longer valid
                    unless valid_parent_project?
                      self.parent_issue_id = nil
                    end
                    @custom_field_values = nil
                    @workflow_rule_by_attribute = nil
                  end
                  self.project
                end
                def description=(arg)
                  if arg.is_a?(String)
                    arg = arg.gsub(/(\r\n|\n|\r)/, "\r\n")
                  end
                  write_attribute(:description, arg)
                end
                # Overrides assign_attributes so that project and tracker get assigned first
                def assign_attributes_with_project_and_tracker_first(new_attributes, *args)
                  return if new_attributes.nil?
                  attrs = new_attributes.dup
                  attrs.stringify_keys!
                  %w(project project_id tracker tracker_id).each do |attr|
                    if attrs.has_key?(attr)
                      send "#{attr}=", attrs.delete(attr)
                    end
                  end
                  send :assign_attributes_without_project_and_tracker_first, attrs, *args
                end
                # Do not redefine alias chain on reload (see #4838)
                alias_method_chain(:assign_attributes, :project_and_tracker_first) unless method_defined?(:assign_attributes_without_project_and_tracker_first)
                def attributes=(new_attributes)
                  assign_attributes new_attributes
                end
                def estimated_hours=(h)
                  write_attribute :estimated_hours, (h.is_a?(String) ? h.to_hours : h)
                end
                safe_attributes 'project_id',
                  :if => lambda {|issue, user|
                    if issue.new_record?
                      issue.copy?
                    elsif user.allowed_to?(:move_issues, issue.project)
                      Issue.allowed_target_projects_on_move.count > 1
                    end
                  }
                safe_attributes 'tracker_id',
                  'status_id',
                  'category_id',
                  'assigned_to_id',
                  'priority_id',
                  'fixed_version_id',
                  'subject',
                  'description',
                  'start_date',
                  'due_date',
                  'done_ratio',
                  'estimated_hours',
                  'custom_field_values',
                  'custom_fields',
                  'lock_version',
                  'notes',
                  :if => lambda {|issue, user| issue.new_record? || user.allowed_to?(:edit_issues, issue.project) }
                safe_attributes 'notes',
                  :if => lambda {|issue, user| user.allowed_to?(:add_issue_notes, issue.project)}
                safe_attributes 'private_notes',
                  :if => lambda {|issue, user| !issue.new_record? && user.allowed_to?(:set_notes_private, issue.project)}
                safe_attributes 'watcher_user_ids',
                  :if => lambda {|issue, user| issue.new_record? && user.allowed_to?(:add_issue_watchers, issue.project)}
                safe_attributes 'is_private',
                  :if => lambda {|issue, user|
                    user.allowed_to?(:set_issues_private, issue.project) ||
                      (issue.author_id == user.id && user.allowed_to?(:set_own_issues_private, issue.project))
                  }
                safe_attributes 'parent_issue_id',
                  :if => lambda {|issue, user| (issue.new_record? || user.allowed_to?(:edit_issues, issue.project)) &&
                    user.allowed_to?(:manage_subtasks, issue.project)}
                def safe_attribute_names(user=nil)
                  names = super
                  names -= disabled_core_fields
                  names -= read_only_attribute_names(user)
                  names
                end
                # Safely sets attributes
                # Should be called from controllers instead of #attributes=
                # attr_accessible is too rough because we still want things like
                # Issue.new(:project => foo) to work
                def safe_attributes=(attrs, user=User.current)
                  return unless attrs.is_a?(Hash)
                  attrs = attrs.deep_dup
                  # Project and Tracker must be set before since new_statuses_allowed_to depends on it.
                  if (p = attrs.delete('project_id')) && safe_attribute?('project_id')
                    if allowed_target_projects(user).where(:id => p.to_i).exists?
                      self.project_id = p
                    end
                  end
                  if (t = attrs.delete('tracker_id')) && safe_attribute?('tracker_id')
                    self.tracker_id = t
                  end
                  if (s = attrs.delete('status_id')) && safe_attribute?('status_id')
                    if new_statuses_allowed_to(user).collect(&:id).include?(s.to_i)
                      self.status_id = s
                    end
                  end
                  attrs = delete_unsafe_attributes(attrs, user)
                  return if attrs.empty?
                  unless leaf?
                    attrs.reject! {|k,v| %w(priority_id done_ratio start_date due_date estimated_hours).include?(k)}
                  end
                  if attrs['parent_issue_id'].present?
                    s = attrs['parent_issue_id'].to_s
                    unless (m = s.match(%r{\A#?(\d+)\z})) && (m[1] == parent_id.to_s || Issue.visible(user).exists?(m[1]))
                      @invalid_parent_issue_id = attrs.delete('parent_issue_id')
                    end
                  end
                  if attrs['custom_field_values'].present?
                    editable_custom_field_ids = editable_custom_field_values(user).map {|v| v.custom_field_id.to_s}
                    attrs['custom_field_values'].select! {|k, v| editable_custom_field_ids.include?(k.to_s)}
                  end
                  if attrs['custom_fields'].present?
                    editable_custom_field_ids = editable_custom_field_values(user).map {|v| v.custom_field_id.to_s}
                    attrs['custom_fields'].select! {|c| editable_custom_field_ids.include?(c['id'].to_s)}
                  end
                  # mass-assignment security bypass
                  assign_attributes attrs, :without_protection => true
                end
                def disabled_core_fields
                  tracker ? tracker.disabled_core_fields : []
                end
                # Returns the custom_field_values that can be edited by the given user
                def editable_custom_field_values(user=nil)
                  visible_custom_field_values(user).reject do |value|
                    read_only_attribute_names(user).include?(value.custom_field_id.to_s)
                  end
                end
                # Returns the custom fields that can be edited by the given user
                def editable_custom_fields(user=nil)
                  editable_custom_field_values(user).map(&:custom_field).uniq
                end
                # Returns the names of attributes that are read-only for user or the current user
                # For users with multiple roles, the read-only fields are the intersection of
                # read-only fields of each role
                # The result is an array of strings where sustom fields are represented with their ids
                #
                # Examples:
                #   issue.read_only_attribute_names # => ['due_date', '2']
                #   issue.read_only_attribute_names(user) # => []
                def read_only_attribute_names(user=nil)
                  workflow_rule_by_attribute(user).reject {|attr, rule| rule != 'readonly'}.keys
                end
                # Returns the names of required attributes for user or the current user
                # For users with multiple roles, the required fields are the intersection of
                # required fields of each role
                # The result is an array of strings where sustom fields are represented with their ids
                #
                # Examples:
                #   issue.required_attribute_names # => ['due_date', '2']
                #   issue.required_attribute_names(user) # => []
                def required_attribute_names(user=nil)
                  workflow_rule_by_attribute(user).reject {|attr, rule| rule != 'required'}.keys
                end
                # Returns true if the attribute is required for user
                def required_attribute?(name, user=nil)
                  required_attribute_names(user).include?(name.to_s)
                end
                # Returns a hash of the workflow rule by attribute for the given user
                #
                # Examples:
                #   issue.workflow_rule_by_attribute # => {'due_date' => 'required', 'start_date' => 'readonly'}
                def workflow_rule_by_attribute(user=nil)
                  return @workflow_rule_by_attribute if @workflow_rule_by_attribute && user.nil?
                  user_real = user || User.current
                  roles = user_real.admin ? Role.all.to_a : user_real.roles_for_project(project)
                  roles = roles.select(&:consider_workflow?)
                  return {} if roles.empty?
                  result = {}
                  workflow_permissions = WorkflowPermission.where(:tracker_id => tracker_id, :old_status_id => status_id, :role_id => roles.map(&:id)).to_a
                  if workflow_permissions.any?
                    workflow_rules = workflow_permissions.inject({}) do |h, wp|
                      h[wp.field_name] ||= []
                      h[wp.field_name] << wp.rule
                      h
                    end
                    workflow_rules.each do |attr, rules|
                      next if rules.size < roles.size
                      uniq_rules = rules.uniq
                      if uniq_rules.size == 1
                        result[attr] = uniq_rules.first
                      else
                        result[attr] = 'required'
                      end
                    end
                  end
                  @workflow_rule_by_attribute = result if user.nil?
                  result
                end
                private :workflow_rule_by_attribute
                def done_ratio
                  if Issue.use_status_for_done_ratio? && status && status.default_done_ratio
                    status.default_done_ratio
                  else
                    read_attribute(:done_ratio)
                  end
                end
                def self.use_status_for_done_ratio?
                  Setting.issue_done_ratio == 'issue_status'
                end
                def self.use_field_for_done_ratio?
                  Setting.issue_done_ratio == 'issue_field'
                end
                def validate_issue
                  if due_date && start_date && (start_date_changed? || due_date_changed?) && due_date < start_date
                    errors.add :due_date, :greater_than_start_date
                  end
                  if start_date && start_date_changed? && soonest_start && start_date < soonest_start
                    errors.add :start_date, :earlier_than_minimum_start_date, :date => format_date(soonest_start)
                  end
                  if fixed_version
                    if !assignable_versions.include?(fixed_version)
                      errors.add :fixed_version_id, :inclusion
                    elsif reopening? && fixed_version.closed?
                      errors.add :base, I18n.t(:error_can_not_reopen_issue_on_closed_version)
                    end
                  end
                  # Checks that the issue can not be added/moved to a disabled tracker
                  if project && (tracker_id_changed? || project_id_changed?)
                    unless project.trackers.include?(tracker)
                      errors.add :tracker_id, :inclusion
                    end
                  end
                  # Checks parent issue assignment
                  if @invalid_parent_issue_id.present?
                    errors.add :parent_issue_id, :invalid
                  elsif @parent_issue
                    if !valid_parent_project?(@parent_issue)
                      errors.add :parent_issue_id, :invalid
                    elsif (@parent_issue != parent) && (all_dependent_issues.include?(@parent_issue) || @parent_issue.all_dependent_issues.include?(self))
                      errors.add :parent_issue_id, :invalid
                    elsif !new_record?
                      # moving an existing issue
                      if move_possible?(@parent_issue)
                        # move accepted
                      else
                        errors.add :parent_issue_id, :invalid
                      end
                    end
                  end
                end
                # Validates the issue against additional workflow requirements
                def validate_required_fields
                  user = new_record? ? author : current_journal.try(:user)
                  required_attribute_names(user).each do |attribute|
                    if attribute =~ /^\d+$/
                      attribute = attribute.to_i
                      v = custom_field_values.detect {|v| v.custom_field_id == attribute }
                      if v && v.value.blank?
                        errors.add :base, v.custom_field.name + ' ' + l('activerecord.errors.messages.blank')
                      end
                    else
                      if respond_to?(attribute) && send(attribute).blank? && !disabled_core_fields.include?(attribute)
                        errors.add attribute, :blank
                      end
                    end
                  end
                end
                # Set the done_ratio using the status if that setting is set.  This will keep the done_ratios
                # even if the user turns off the setting later
                def update_done_ratio_from_issue_status
                  if Issue.use_status_for_done_ratio? && status && status.default_done_ratio
                    self.done_ratio = status.default_done_ratio
                  end
                end
                def init_journal(user, notes = "")
                  @current_journal ||= Journal.new(:journalized => self, :user => user, :notes => notes)
                end
                # Returns the current journal or nil if it's not initialized
                def current_journal
                  @current_journal
                end
                # Returns the names of attributes that are journalized when updating the issue
                def journalized_attribute_names
                  Issue.column_names - %w(id root_id lft rgt lock_version created_on updated_on closed_on)
                end
                # Returns the id of the last journal or nil
                def last_journal_id
                  if new_record?
                    nil
                  else
                    journals.maximum(:id)
                  end
                end
                # Returns a scope for journals that have an id greater than journal_id
                def journals_after(journal_id)
                  scope = journals.reorder("#{Journal.table_name}.id ASC")
                  if journal_id.present?
                    scope = scope.where("#{Journal.table_name}.id > ?", journal_id.to_i)
                  end
                  scope
                end
                # Returns the initial status of the issue
                # Returns nil for a new issue
                def status_was
                  if status_id_changed?
                    if status_id_was.to_i > 0
                      @status_was ||= IssueStatus.find_by_id(status_id_was)
                    end
                  else
                    @status_was ||= status
                  end
                end
                # Return true if the issue is closed, otherwise false
                def closed?
                  status.present? && status.is_closed?
                end
                # Returns true if the issue was closed when loaded
                def was_closed?
                  status_was.present? && status_was.is_closed?
                end
                # Return true if the issue is being reopened
                def reopening?
                  if new_record?
                    false
                  else
                    status_id_changed? && !closed? && was_closed?
                  end
                end
                alias :reopened? :reopening?
                # Return true if the issue is being closed
                def closing?
                  if new_record?
                    closed?
                  else
                    status_id_changed? && closed? && !was_closed?
                  end
                end
                # Returns true if the issue is overdue
                def overdue?
                  due_date.present? && (due_date < Date.today) && !closed?
                end
                # Is the amount of work done less than it should for the due date
                def behind_schedule?
                  return false if start_date.nil? || due_date.nil?
                  done_date = start_date + ((due_date - start_date + 1) * done_ratio / 100).floor
                  return done_date <= Date.today
                end
                # Does this issue have children?
                def children?
                  !leaf?
                end
                # Users the issue can be assigned to
                def assignable_users
                  users = project.assignable_users.to_a
                  users << author if author
                  users << assigned_to if assigned_to
                  users.uniq.sort
                end
                # Versions that the issue can be assigned to
                def assignable_versions
                  return @assignable_versions if @assignable_versions
                  versions = project.shared_versions.open.to_a
                  if fixed_version
                    if fixed_version_id_changed?
                      # nothing to do
                    elsif project_id_changed?
                      if project.shared_versions.include?(fixed_version)
                        versions << fixed_version
                      end
                    else
                      versions << fixed_version
                    end
                  end
                  @assignable_versions = versions.uniq.sort
                end
                # Returns true if this issue is blocked by another issue that is still open
                def blocked?
                  !relations_to.detect {|ir| ir.relation_type == 'blocks' && !ir.issue_from.closed?}.nil?
                end
                # Returns the default status of the issue based on its tracker
                # Returns nil if tracker is nil
                def default_status
                  tracker.try(:default_status)
                end
                # Returns an array of statuses that user is able to apply
                def new_statuses_allowed_to(user=User.current, include_default=false)
                  if new_record? && @copied_from
                    [default_status, @copied_from.status].compact.uniq.sort
                  else
                    initial_status = nil
                    if new_record?
                      initial_status = default_status
                    elsif tracker_id_changed?
                      if Tracker.where(:id => tracker_id_was, :default_status_id => status_id_was).any?
                        initial_status = default_status
                      elsif tracker.issue_status_ids.include?(status_id_was)
                        initial_status = IssueStatus.find_by_id(status_id_was)
                      else
                        initial_status = default_status
                      end
                    else
                      initial_status = status_was
                    end
                    initial_assigned_to_id = assigned_to_id_changed? ? assigned_to_id_was : assigned_to_id
                    assignee_transitions_allowed = initial_assigned_to_id.present? &&
                      (user.id == initial_assigned_to_id || user.group_ids.include?(initial_assigned_to_id))
                    statuses = []
                    if initial_status
                      statuses += initial_status.find_new_statuses_allowed_to(
                        user.admin ? Role.all.to_a : user.roles_for_project(project),
                        tracker,
                        author == user,
                        assignee_transitions_allowed
                        )
                    end
                    statuses << initial_status unless statuses.empty?
                    statuses << default_status if include_default
                    statuses = statuses.compact.uniq.sort
                    if blocked?
                      statuses.reject!(&:is_closed?)
                    end
                    statuses
                  end
                end
                # Returns the previous assignee if changed
                def assigned_to_was
                  # assigned_to_id_was is reset before after_save callbacks
                  user_id = @previous_assigned_to_id || assigned_to_id_was
                  if user_id && user_id != assigned_to_id
                    @assigned_to_was ||= User.find_by_id(user_id)
                  end
                end
                # Returns the users that should be notified
                def notified_users
                  notified = []
                  # Author and assignee are always notified unless they have been
                  # locked or don't want to be notified
                  notified << author if author
                  if assigned_to
                    notified += (assigned_to.is_a?(Group) ? assigned_to.users : [assigned_to])
                  end
                  if assigned_to_was
                    notified += (assigned_to_was.is_a?(Group) ? assigned_to_was.users : [assigned_to_was])
                  end
                  notified = notified.select {|u| u.active? && u.notify_about?(self)}
                  notified += project.notified_users
                  notified.uniq!
                  # Remove users that can not view the issue
                  notified.reject! {|user| !visible?(user)}
                  notified
                end
                # Returns the email addresses that should be notified
                def recipients
                  notified_users.collect(&:mail)
                end
                def each_notification(users, &block)
                  if users.any?
                    if custom_field_values.detect {|value| !value.custom_field.visible?}
                      users_by_custom_field_visibility = users.group_by do |user|
                        visible_custom_field_values(user).map(&:custom_field_id).sort
                      end
                      users_by_custom_field_visibility.values.each do |users|
                        yield(users)
                      end
                    else
                      yield(users)
                    end
                  end
                end
                # Returns the number of hours spent on this issue
                def spent_hours
                  @spent_hours ||= time_entries.sum(:hours) || 0
                end
                # Returns the total number of hours spent on this issue and its descendants
                #
                # Example:
                #   spent_hours => 0.0
                #   spent_hours => 50.2
                def total_spent_hours
                  @total_spent_hours ||=
                    self_and_descendants.
                      joins("LEFT JOIN #{TimeEntry.table_name} ON #{TimeEntry.table_name}.issue_id = #{Issue.table_name}.id").
                      sum("#{TimeEntry.table_name}.hours").to_f || 0.0
                end
                def relations
                  @relations ||= IssueRelation::Relations.new(self, (relations_from + relations_to).sort)
                end
                # Preloads relations for a collection of issues
                def self.load_relations(issues)
                  if issues.any?
                    relations = IssueRelation.where("issue_from_id IN (:ids) OR issue_to_id IN (:ids)", :ids => issues.map(&:id)).all
                    issues.each do |issue|
                      issue.instance_variable_set "@relations", relations.select {|r| r.issue_from_id == issue.id || r.issue_to_id == issue.id}
                    end
                  end
                end
                # Preloads visible spent time for a collection of issues
                def self.load_visible_spent_hours(issues, user=User.current)
                  if issues.any?
                    hours_by_issue_id = TimeEntry.visible(user).group(:issue_id).sum(:hours)
                    issues.each do |issue|
                      issue.instance_variable_set "@spent_hours", (hours_by_issue_id[issue.id] || 0)
                    end
                  end
                end
                # Preloads visible relations for a collection of issues
                def self.load_visible_relations(issues, user=User.current)
                  if issues.any?
                    issue_ids = issues.map(&:id)
                    # Relations with issue_from in given issues and visible issue_to
                    relations_from = IssueRelation.joins(:issue_to => :project).
                                       where(visible_condition(user)).where(:issue_from_id => issue_ids).to_a
                    # Relations with issue_to in given issues and visible issue_from
                    relations_to = IssueRelation.joins(:issue_from => :project).
                                       where(visible_condition(user)).
                                       where(:issue_to_id => issue_ids).to_a
                    issues.each do |issue|
                      relations =
                        relations_from.select {|relation| relation.issue_from_id == issue.id} +
                        relations_to.select {|relation| relation.issue_to_id == issue.id}
                      issue.instance_variable_set "@relations", IssueRelation::Relations.new(issue, relations.sort)
                    end
                  end
                end
                # Finds an issue relation given its id.
                def find_relation(relation_id)
                  IssueRelation.where("issue_to_id = ? OR issue_from_id = ?", id, id).find(relation_id)
                end
                # Returns all the other issues that depend on the issue
                # The algorithm is a modified breadth first search (bfs)
                def all_dependent_issues(except=[])
                  # The found dependencies
                  dependencies = []
                  # The visited flag for every node (issue) used by the breadth first search
                  eNOT_DISCOVERED         = 0       # The issue is "new" to the algorithm, it has not seen it before.
                  ePROCESS_ALL            = 1       # The issue is added to the queue. Process both children and relations of
                                                    # the issue when it is processed.
                  ePROCESS_RELATIONS_ONLY = 2       # The issue was added to the queue and will be output as dependent issue,
                                                    # but its children will not be added to the queue when it is processed.
                  eRELATIONS_PROCESSED    = 3       # The related issues, the parent issue and the issue itself have been added to
                                                    # the queue, but its children have not been added.
                  ePROCESS_CHILDREN_ONLY  = 4       # The relations and the parent of the issue have been added to the queue, but
                                                    # the children still need to be processed.
                  eALL_PROCESSED          = 5       # The issue and all its children, its parent and its related issues have been
                                                    # added as dependent issues. It needs no further processing.
                  issue_status = Hash.new(eNOT_DISCOVERED)
                  # The queue
                  queue = []
                  # Initialize the bfs, add start node (self) to the queue
                  queue << self
                  issue_status[self] = ePROCESS_ALL
                  while (!queue.empty?) do
                    current_issue = queue.shift
                    current_issue_status = issue_status[current_issue]
                    dependencies << current_issue
                    # Add parent to queue, if not already in it.
                    parent = current_issue.parent
                    parent_status = issue_status[parent]
                    if parent && (parent_status == eNOT_DISCOVERED) && !except.include?(parent)
                      queue << parent
                      issue_status[parent] = ePROCESS_RELATIONS_ONLY
                    end
                    # Add children to queue, but only if they are not already in it and
                    # the children of the current node need to be processed.
                    if (current_issue_status == ePROCESS_CHILDREN_ONLY || current_issue_status == ePROCESS_ALL)
                      current_issue.children.each do |child|
                        next if except.include?(child)
                        if (issue_status[child] == eNOT_DISCOVERED)
                          queue << child
                          issue_status[child] = ePROCESS_ALL
                        elsif (issue_status[child] == eRELATIONS_PROCESSED)
                          queue << child
                          issue_status[child] = ePROCESS_CHILDREN_ONLY
                        elsif (issue_status[child] == ePROCESS_RELATIONS_ONLY)
                          queue << child
                          issue_status[child] = ePROCESS_ALL
                        end
                      end
                    end
                    # Add related issues to the queue, if they are not already in it.
                    current_issue.relations_from.map(&:issue_to).each do |related_issue|
                      next if except.include?(related_issue)
                      if (issue_status[related_issue] == eNOT_DISCOVERED)
                        queue << related_issue
                        issue_status[related_issue] = ePROCESS_ALL
                      elsif (issue_status[related_issue] == eRELATIONS_PROCESSED)
                        queue << related_issue
                        issue_status[related_issue] = ePROCESS_CHILDREN_ONLY
                      elsif (issue_status[related_issue] == ePROCESS_RELATIONS_ONLY)
                        queue << related_issue
                        issue_status[related_issue] = ePROCESS_ALL
                      end
                    end
                    # Set new status for current issue
                    if (current_issue_status == ePROCESS_ALL) || (current_issue_status == ePROCESS_CHILDREN_ONLY)
                      issue_status[current_issue] = eALL_PROCESSED
                    elsif (current_issue_status == ePROCESS_RELATIONS_ONLY)
                      issue_status[current_issue] = eRELATIONS_PROCESSED
                    end
                  end # while
                  # Remove the issues from the "except" parameter from the result array
                  dependencies -= except
                  dependencies.delete(self)
                  dependencies
                end
                # Returns an array of issues that duplicate this one
                def duplicates
                  relations_to.select {|r| r.relation_type == IssueRelation::TYPE_DUPLICATES}.collect {|r| r.issue_from}
                end
                # Returns the due date or the target due date if any
                # Used on gantt chart
                def due_before
                  due_date || (fixed_version ? fixed_version.effective_date : nil)
                end
                # Returns the time scheduled for this issue.
                #
                # Example:
                #   Start Date: 2/26/09, End Date: 3/04/09
                #   duration => 6
                def duration
                  (start_date && due_date) ? due_date - start_date : 0
                end
                # Returns the duration in working days
                def working_duration
                  (start_date && due_date) ? working_days(start_date, due_date) : 0
                end
                def soonest_start(reload=false)
                  @soonest_start = nil if reload
                  @soonest_start ||= (
                      relations_to(reload).collect{|relation| relation.successor_soonest_start} +
                      [(@parent_issue || parent).try(:soonest_start)]
                    ).compact.max
                end
                # Sets start_date on the given date or the next working day
                # and changes due_date to keep the same working duration.
                def reschedule_on(date)
                  wd = working_duration
                  date = next_working_date(date)
                  self.start_date = date
                  self.due_date = add_working_days(date, wd)
                end
                # Reschedules the issue on the given date or the next working day and saves the record.
                # If the issue is a parent task, this is done by rescheduling its subtasks.
                def reschedule_on!(date)
                  return if date.nil?
                  if leaf?
                    if start_date.nil? || start_date != date
                      if start_date && start_date > date
                        # Issue can not be moved earlier than its soonest start date
                        date = [soonest_start(true), date].compact.max
                      end
                      reschedule_on(date)
                      begin
                        save
                      rescue ActiveRecord::StaleObjectError
                        reload
                        reschedule_on(date)
                        save
                      end
                    end
                  else
                    leaves.each do |leaf|
                      if leaf.start_date
                        # Only move subtask if it starts at the same date as the parent
                        # or if it starts before the given date
                        if start_date == leaf.start_date || date > leaf.start_date
                          leaf.reschedule_on!(date)
                        end
                      else
                        leaf.reschedule_on!(date)
                      end
                    end
                  end
                end
                def <=>(issue)
                  if issue.nil?
                    -1
                  elsif root_id != issue.root_id
                    (root_id || 0) <=> (issue.root_id || 0)
                  else
                    (lft || 0) <=> (issue.lft || 0)
                  end
                end
                def to_s
                  "#{tracker} ##{id}: #{subject}"
                end
                # Returns a string of css classes that apply to the issue
                def css_classes(user=User.current)
                  s = "issue tracker-#{tracker_id} status-#{status_id} #{priority.try(:css_classes)}"
                  s << ' closed' if closed?
                  s << ' overdue' if overdue?
                  s << ' child' if child?
                  s << ' parent' unless leaf?
                  s << ' private' if is_private?
                  if user.logged?
                    s << ' created-by-me' if author_id == user.id
                    s << ' assigned-to-me' if assigned_to_id == user.id
                    s << ' assigned-to-my-group' if user.groups.any? {|g| g.id == assigned_to_id}
                  end
                  s
                end
                # Unassigns issues from +version+ if it's no longer shared with issue's project
                def self.update_versions_from_sharing_change(version)
                  # Update issues assigned to the version
                  update_versions(["#{Issue.table_name}.fixed_version_id = ?", version.id])
                end
                # Unassigns issues from versions that are no longer shared
                # after +project+ was moved
                def self.update_versions_from_hierarchy_change(project)
                  moved_project_ids = project.self_and_descendants.reload.collect(&:id)
                  # Update issues of the moved projects and issues assigned to a version of a moved project
                  Issue.update_versions(
                          ["#{Version.table_name}.project_id IN (?) OR #{Issue.table_name}.project_id IN (?)",
                           moved_project_ids, moved_project_ids]
                        )
                end
                def parent_issue_id=(arg)
                  s = arg.to_s.strip.presence
                  if s && (m = s.match(%r{\A#?(\d+)\z})) && (@parent_issue = Issue.find_by_id(m[1]))
                    @invalid_parent_issue_id = nil
                  elsif s.blank?
                    @parent_issue = nil
                    @invalid_parent_issue_id = nil
                  else
                    @parent_issue = nil
                    @invalid_parent_issue_id = arg
                  end
                end
                def parent_issue_id
                  if @invalid_parent_issue_id
                    @invalid_parent_issue_id
                  elsif instance_variable_defined? :@parent_issue
                    @parent_issue.nil? ? nil : @parent_issue.id
                  else
                    parent_id
                  end
                end
                def set_parent_id
                  self.parent_id = parent_issue_id
                end
                # Returns true if issue's project is a valid
                # parent issue project
                def valid_parent_project?(issue=parent)
                  return true if issue.nil? || issue.project_id == project_id
                  case Setting.cross_project_subtasks
                  when 'system'
                    true
                  when 'tree'
                    issue.project.root == project.root
                  when 'hierarchy'
                    issue.project.is_or_is_ancestor_of?(project) || issue.project.is_descendant_of?(project)
                  when 'descendants'
                    issue.project.is_or_is_ancestor_of?(project)
                  else
                    false
                  end
                end
                # Returns an issue scope based on project and scope
                def self.cross_project_scope(project, scope=nil)
                  if project.nil?
                    return Issue
                  end
                  case scope
                  when 'all', 'system'
                    Issue
                  when 'tree'
                    Issue.joins(:project).where("(#{Project.table_name}.lft >= :lft AND #{Project.table_name}.rgt <= :rgt)",
                                                :lft => project.root.lft, :rgt => project.root.rgt)
                  when 'hierarchy'
                    Issue.joins(:project).where("(#{Project.table_name}.lft >= :lft AND #{Project.table_name}.rgt <= :rgt) OR (#{Project.table_name}.lft < :lft AND #{Project.table_name}.rgt > :rgt)",
                                                :lft => project.lft, :rgt => project.rgt)
                  when 'descendants'
                    Issue.joins(:project).where("(#{Project.table_name}.lft >= :lft AND #{Project.table_name}.rgt <= :rgt)",
                                                :lft => project.lft, :rgt => project.rgt)
                  else
                    Issue.where(:project_id => project.id)
                  end
                end
                def self.by_tracker(project)
                  count_and_group_by(:project => project, :association => :tracker)
                end
                def self.by_version(project)
                  count_and_group_by(:project => project, :association => :fixed_version)
                end
                def self.by_priority(project)
                  count_and_group_by(:project => project, :association => :priority)
                end
                def self.by_category(project)
                  count_and_group_by(:project => project, :association => :category)
                end
                def self.by_assigned_to(project)
                  count_and_group_by(:project => project, :association => :assigned_to)
                end
                def self.by_author(project)
                  count_and_group_by(:project => project, :association => :author)
                end
                def self.by_subproject(project)
                  r = count_and_group_by(:project => project, :with_subprojects => true, :association => :project)
                  r.reject {|r| r["project_id"] == project.id.to_s}
                end
                # Query generator for selecting groups of issue counts for a project
                # based on specific criteria
                #
                # Options
                # * project - Project to search in.
                # * with_subprojects - Includes subprojects issues if set to true.
                # * association - Symbol. Association for grouping.
                def self.count_and_group_by(options)
                  assoc = reflect_on_association(options[:association])
                  select_field = assoc.foreign_key
                  Issue.
                    visible(User.current, :project => options[:project], :with_subprojects => options[:with_subprojects]).
                    joins(:status, assoc.name).
                    group(:status_id, :is_closed, select_field).
                    count.
                    map do |columns, total|
                      status_id, is_closed, field_value = columns
                      is_closed = ['t', 'true', '1'].include?(is_closed.to_s)
                      {
                        "status_id" => status_id.to_s,
                        "closed" => is_closed,
                        select_field => field_value.to_s,
                        "total" => total.to_s
                      }
                    end
                end
                # Returns a scope of projects that user can assign the issue to
                def allowed_target_projects(user=User.current)
                  if new_record?
                    Project.where(Project.allowed_to_condition(user, :add_issues))
                  else
                    self.class.allowed_target_projects_on_move(user)
                  end
                end
                # Returns a scope of projects that user can move issues to
                def self.allowed_target_projects_on_move(user=User.current)
                  Project.where(Project.allowed_to_condition(user, :move_issues))
                end
                private
                def after_project_change
                  # Update project_id on related time entries
                  TimeEntry.where({:issue_id => id}).update_all(["project_id = ?", project_id])
                  # Delete issue relations
                  unless Setting.cross_project_issue_relations?
                    relations_from.clear
                    relations_to.clear
                  end
                  # Move subtasks that were in the same project
                  children.each do |child|
                    next unless child.project_id == project_id_was
                    # Change project and keep project
                    child.send :project=, project, true
                    unless child.save
                      raise ActiveRecord::Rollback
                    end
                  end
                end
                # Callback for after the creation of an issue by copy
                # * adds a "copied to" relation with the copied issue
                # * copies subtasks from the copied issue
                def after_create_from_copy
                  return unless copy? && !@after_create_from_copy_handled
                  if (@copied_from.project_id == project_id || Setting.cross_project_issue_relations?) && @copy_options[:link] != false
                    if @current_journal
                      @copied_from.init_journal(@current_journal.user)
                    end
                    relation = IssueRelation.new(:issue_from => @copied_from, :issue_to => self, :relation_type => IssueRelation::TYPE_COPIED_TO)
                    unless relation.save
                      logger.error "Could not create relation while copying ##{@copied_from.id} to ##{id} due to validation errors: #{relation.errors.full_messages.join(', ')}" if logger
                    end
                  end
                  unless @copied_from.leaf? || @copy_options[:subtasks] == false
                    copy_options = (@copy_options || {}).merge(:subtasks => false)
                    copied_issue_ids = {@copied_from.id => self.id}
                    @copied_from.reload.descendants.reorder("#{Issue.table_name}.lft").each do |child|
                      # Do not copy self when copying an issue as a descendant of the copied issue
                      next if child == self
                      # Do not copy subtasks of issues that were not copied
                      next unless copied_issue_ids[child.parent_id]
                      # Do not copy subtasks that are not visible to avoid potential disclosure of private data
                      unless child.visible?
                        logger.error "Subtask ##{child.id} was not copied during ##{@copied_from.id} copy because it is not visible to the current user" if logger
                        next
                      end
                      copy = Issue.new.copy_from(child, copy_options)
                      if @current_journal
                        copy.init_journal(@current_journal.user)
                      end
                      copy.author = author
                      copy.project = project
                      copy.parent_issue_id = copied_issue_ids[child.parent_id]
                      unless copy.save
                        logger.error "Could not copy subtask ##{child.id} while copying ##{@copied_from.id} to ##{id} due to validation errors: #{copy.errors.full_messages.join(', ')}" if logger
                        next
                      end
                      copied_issue_ids[child.id] = copy.id
                    end
                  end
                  @after_create_from_copy_handled = true
                end
                def update_nested_set_attributes
                  if parent_id_changed?
                    update_nested_set_attributes_on_parent_change
                  end
                  remove_instance_variable(:@parent_issue) if instance_variable_defined?(:@parent_issue)
                end
                # Updates the nested set for when an existing issue is moved
                def update_nested_set_attributes_on_parent_change
                  former_parent_id = parent_id_was
                  # delete invalid relations of all descendants
                  self_and_descendants.each do |issue|
                    issue.relations.each do |relation|
                      relation.destroy unless relation.valid?
                    end
                  end
                  # update former parent
                  recalculate_attributes_for(former_parent_id) if former_parent_id
                end
                def update_parent_attributes
                  if parent_id
                    recalculate_attributes_for(parent_id)
                    association(:parent).reset
                  end
                end
                def recalculate_attributes_for(issue_id)
                  if issue_id && p = Issue.find_by_id(issue_id)
                    # priority = highest priority of children
                    if priority_position = p.children.joins(:priority).maximum("#{IssuePriority.table_name}.position")
                      p.priority = IssuePriority.find_by_position(priority_position)
                    end
                    # start/due dates = lowest/highest dates of children
                    p.start_date = p.children.minimum(:start_date)
                    p.due_date = p.children.maximum(:due_date)
                    if p.start_date && p.due_date && p.due_date < p.start_date
                      p.start_date, p.due_date = p.due_date, p.start_date
                    end
                    # done ratio = weighted average ratio of leaves
                    unless Issue.use_status_for_done_ratio? && p.status && p.status.default_done_ratio
                      leaves_count = p.leaves.count
                      if leaves_count > 0
                        average = p.leaves.where("estimated_hours > 0").average(:estimated_hours).to_f
                        if average == 0
                          average = 1
                        end
                        done = p.leaves.joins(:status).
                          sum("COALESCE(CASE WHEN estimated_hours > 0 THEN estimated_hours ELSE NULL END, #{average}) " +
                              "* (CASE WHEN is_closed = #{self.class.connection.quoted_true} THEN 100 ELSE COALESCE(done_ratio, 0) END)").to_f
                        progress = done / (average * leaves_count)
                        p.done_ratio = progress.round
                      end
                    end
                    # estimate = sum of leaves estimates
                    p.estimated_hours = p.leaves.sum(:estimated_hours).to_f
                    p.estimated_hours = nil if p.estimated_hours == 0.0
                    # ancestors will be recursively updated
                    p.save(:validate => false)
                  end
                end
                # Update issues so their versions are not pointing to a
                # fixed_version that is not shared with the issue's project
                def self.update_versions(conditions=nil)
                  # Only need to update issues with a fixed_version from
                  # a different project and that is not systemwide shared
                  Issue.joins(:project, :fixed_version).
                    where("#{Issue.table_name}.fixed_version_id IS NOT NULL" +
                      " AND #{Issue.table_name}.project_id <> #{Version.table_name}.project_id" +
                      " AND #{Version.table_name}.sharing <> 'system'").
                    where(conditions).each do |issue|
                    next if issue.project.nil? || issue.fixed_version.nil?
                    unless issue.project.shared_versions.include?(issue.fixed_version)
                      issue.init_journal(User.current)
                      issue.fixed_version = nil
                      issue.save
                    end
                  end
                end
                # Callback on file attachment
                def attachment_added(attachment)
                  if current_journal && !attachment.new_record?
                    current_journal.journalize_attachment(attachment, :added)
                  end
                end
                # Callback on attachment deletion
                def attachment_removed(attachment)
                  if current_journal && !attachment.new_record?
                    current_journal.journalize_attachment(attachment, :removed)
                    current_journal.save
                  end
                end
                # Called after a relation is added
                def relation_added(relation)
                  if current_journal
                    current_journal.journalize_relation(relation, :added)
                    current_journal.save
                  end
                end
                # Called after a relation is removed
                def relation_removed(relation)
                  if current_journal
                    current_journal.journalize_relation(relation, :removed)
                    current_journal.save
                  end
                end
                # Default assignment based on category
                def default_assign
                  if assigned_to.nil? && category && category.assigned_to
                    self.assigned_to = category.assigned_to
                  end
                end
                # Updates start/due dates of following issues
                def reschedule_following_issues
                  if start_date_changed? || due_date_changed?
                    relations_from.each do |relation|
                      relation.set_issue_to_dates
                    end
                  end
                end
                # Closes duplicates if the issue is being closed
                def close_duplicates
                  if closing?
                    duplicates.each do |duplicate|
                      # Reload is needed in case the duplicate was updated by a previous duplicate
                      duplicate.reload
                      # Don't re-close it if it's already closed
                      next if duplicate.closed?
                      # Same user and notes
                      if @current_journal
                        duplicate.init_journal(@current_journal.user, @current_journal.notes)
                      end
                      duplicate.update_attribute :status, self.status
                    end
                  end
                end
                # Make sure updated_on is updated when adding a note and set updated_on now
                # so we can set closed_on with the same value on closing
                def force_updated_on_change
                  if @current_journal || changed?
                    self.updated_on = current_time_from_proper_timezone
                    if new_record?
                      self.created_on = updated_on
                    end
                  end
                end
                # Callback for setting closed_on when the issue is closed.
                # The closed_on attribute stores the time of the last closing
                # and is preserved when the issue is reopened.
                def update_closed_on
                  if closing?
                    self.closed_on = updated_on
                  end
                end
                # Saves the changes in a Journal
                # Called after_save
                def create_journal
                  if current_journal
                    current_journal.save
                  end
                end
                def send_notification
                  if Setting.notified_events.include?('issue_added')
                    Mailer.deliver_issue_add(self)
                  end
                end
                # Stores the previous assignee so we can still have access
                # to it during after_save callbacks (assigned_to_id_was is reset)
                def set_assigned_to_was
                  @previous_assigned_to_id = assigned_to_id_was
                end
                # Clears the previous assignee at the end of after_save callbacks
                def clear_assigned_to_was
                  @assigned_to_was = nil
                  @previous_assigned_to_id = nil
                end
              end

app/models/journal_detail.rb +7 -5

              # Redmine - project management software
              # Copyright (C) 2006-2015  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.
              class JournalDetail < ActiveRecord::Base
                belongs_to :journal
-               before_save :normalize_values
                attr_protected :id
                def custom_field
                  if property == 'cf'
                    @custom_field ||= CustomField.find_by_id(prop_key)
                  end
                end
-               private
+               def value=(arg)
+                 write_attribute :value, normalize(arg)
+               end
-               def normalize_values
-                 self.value = normalize(value)
-                 self.old_value = normalize(old_value)
+               def old_value=(arg)
+                 write_attribute :old_value, normalize(arg)
                end
+               private
                def normalize(v)
                  case v
                  when true
                    "1"
                  when false
                    "0"
                  when Date
                    v.strftime("%Y-%m-%d")
                  else
                    v
                  end
                end
              end

app/views/users/index.html.erb +1 -1

              <div class="contextual">
              <%= link_to l(:label_user_new), new_user_path, :class => 'icon icon-add' %>
              </div>
              <h2><%=l(:label_user_plural)%></h2>
              <%= form_tag(users_path, :method => :get) do %>
              <fieldset><legend><%= l(:label_filter_plural) %></legend>
              <label for='status'><%= l(:field_status) %>:</label>
              <%= select_tag 'status', users_status_options_for_select(@status), :class => "small", :onchange => "this.form.submit(); return false;"  %>
              <% if @groups.present? %>
              <label for='group_id'><%= l(:label_group) %>:</label>
              <%= select_tag 'group_id', content_tag('option') + options_from_collection_for_select(@groups, :id, :name, params[:group_id].to_i), :onchange => "this.form.submit(); return false;"  %>
              <% end %>
              <label for='name'><%= l(:label_user) %>:</label>
              <%= text_field_tag 'name', params[:name], :size => 30 %>
              <%= submit_tag l(:button_apply), :class => "small", :name => nil %>
              <%= link_to l(:button_clear), users_path, :class => 'icon icon-reload' %>
              </fieldset>
              <% end %>
              &nbsp;
              <div class="autoscroll">
              <table class="list">
                <thead><tr>
                <%= sort_header_tag('login', :caption => l(:field_login)) %>
                <%= sort_header_tag('firstname', :caption => l(:field_firstname)) %>
                <%= sort_header_tag('lastname', :caption => l(:field_lastname)) %>
                <%= sort_header_tag('mail', :caption => l(:field_mail)) %>
                <%= sort_header_tag('admin', :caption => l(:field_admin), :default_order => 'desc') %>
                <%= sort_header_tag('created_on', :caption => l(:field_created_on), :default_order => 'desc') %>
                <%= sort_header_tag('last_login_on', :caption => l(:field_last_login_on), :default_order => 'desc') %>
                  <th></th>
                </tr></thead>
                <tbody>
              <% for user in @users -%>
                <tr class="<%= user.css_classes %> <%= cycle("odd", "even") %>">
                <td class="username"><%= avatar(user, :size => "14") %><%= link_to h(user.login), edit_user_path(user) %></td>
                <td class="firstname"><%= h(user.firstname) %></td>
                <td class="lastname"><%= h(user.lastname) %></td>
                <td class="email"><%= mail_to(h(user.mail)) %></td>
                <td class="tick"><%= checked_image user.admin? %></td>
                <td class="created_on"><%= format_time(user.created_on) %></td>
                <td class="last_login_on"><%= format_time(user.last_login_on) unless user.last_login_on.nil? %></td>
                  <td class="buttons">
                    <%= change_status_link(user) %>
-                   <%= delete_link user_path(user, :back_url => users_path(params)) unless User.current == user %>
+                   <%= delete_link user_path(user, :back_url => request.original_fullpath) unless User.current == user %>
                  </td>
                </tr>
              <% end -%>
                </tbody>
              </table>
              </div>
              <p class="pagination"><%= pagination_links_full @user_pages, @user_count %></p>
              <% html_title(l(:label_user_plural)) -%>

config/environments/test.rb +3 -1

              Rails.application.configure do
                # Settings specified here will take precedence over those in config/application.rb
                # The test environment is used exclusively to run your application's
                # test suite.  You never need to work with it otherwise.  Remember that
                # your test database is "scratch space" for the test suite and is wiped
                # and recreated between test runs.  Don't rely on the data there!
                config.cache_classes = true
                # Do not eager load code on boot. This avoids loading your whole application
                # just for the purpose of running a single test. If you are using a tool that
                # preloads Rails for running tests, you may have to set it to true.
                config.eager_load = false
                # Show full error reports and disable caching
                config.consider_all_requests_local = true
                config.action_controller.perform_caching = false
                config.action_mailer.perform_deliveries = true
                # Tell Action Mailer not to deliver emails to the real world.
                # The :test delivery method accumulates sent emails in the
                # ActionMailer::Base.deliveries array.
                config.action_mailer.delivery_method = :test
                # Disable request forgery protection in test environment.
                config.action_controller.allow_forgery_protection = false
                # Print deprecation notices to stderr and the Rails logger.
                config.active_support.deprecation = [:stderr, :log]
-               config.secret_token = 'a secret token for running the tests'
+               config.secret_key_base = 'a secret token for running the tests'
+               config.active_support.test_order = :random
              end

config/initializers/10-patches.rb +11 -25

              require 'active_record'
              module ActiveRecord
                class Base
                  include Redmine::I18n
                  # Translate attribute names for validation errors display
                  def self.human_attribute_name(attr, *args)
                    attr = attr.to_s.sub(/_id$/, '').sub(/^.+\./, '')
                    l("field_#{name.underscore.gsub('/', '_')}_#{attr}", :default => ["field_#{attr}".to_sym, attr])
                  end
                end
                # Undefines private Kernel#open method to allow using `open` scopes in models.
                # See Defect #11545 (http://www.redmine.org/issues/11545) for details.
                class Base
                  class << self
                    undef open
                  end
                end
                class Relation ; undef open ; end
              end
              module ActionView
                module Helpers
                  module DateHelper
                    # distance_of_time_in_words breaks when difference is greater than 30 years
                    def distance_of_date_in_words(from_date, to_date = 0, options = {})
                      from_date = from_date.to_date if from_date.respond_to?(:to_date)
                      to_date = to_date.to_date if to_date.respond_to?(:to_date)
                      distance_in_days = (to_date - from_date).abs
                      I18n.with_options :locale => options[:locale], :scope => :'datetime.distance_in_words' do |locale|
                        case distance_in_days
                          when 0..60     then locale.t :x_days,             :count => distance_in_days.round
                          when 61..720   then locale.t :about_x_months,     :count => (distance_in_days / 30).round
                          else                locale.t :over_x_years,       :count => (distance_in_days / 365).floor
                        end
                      end
                    end
                  end
                end
                class Resolver
                  def find_all(name, prefix=nil, partial=false, details={}, key=nil, locals=[])
                    cached(key, [name, prefix, partial], details, locals) do
                      if details[:formats] & [:xml, :json]
                        details = details.dup
                        details[:formats] = details[:formats].dup + [:api]
                      end
                      find_templates(name, prefix, partial, details)
                    end
                  end
                end
              end
              ActionView::Base.field_error_proc = Proc.new{ |html_tag, instance| html_tag || ''.html_safe }
              # HTML5: <option value=""></option> is invalid, use <option value="">&nbsp;</option> instead
              module ActionView
                module Helpers
                  module Tags
                    class Base
                      private
                      def add_options_with_non_empty_blank_option(option_tags, options, value = nil)
                        if options[:include_blank] == true
                          options = options.dup
                          options[:include_blank] = '&nbsp;'.html_safe
                        end
                        add_options_without_non_empty_blank_option(option_tags, options, value)
                      end
                      alias_method_chain :add_options, :non_empty_blank_option
                    end
                  end
                  module FormTagHelper
                    def select_tag_with_non_empty_blank_option(name, option_tags = nil, options = {})
                      if options.delete(:include_blank)
                        options[:prompt] = '&nbsp;'.html_safe
                      end
                      select_tag_without_non_empty_blank_option(name, option_tags, options)
                    end
                    alias_method_chain :select_tag, :non_empty_blank_option
                  end
                  module FormOptionsHelper
                    def options_for_select_with_non_empty_blank_option(container, selected = nil)
                      if container.is_a?(Array)
                        container = container.map {|element| element.blank? ? ["&nbsp;".html_safe, ""] : element}
                      end
                      options_for_select_without_non_empty_blank_option(container, selected)
                    end
                    alias_method_chain :options_for_select, :non_empty_blank_option
                  end
                end
              end
              require 'mail'
              module DeliveryMethods
                class AsyncSMTP < ::Mail::SMTP
                  def deliver!(*args)
                    Thread.start do
                      super *args
                    end
                  end
                end
                class AsyncSendmail < ::Mail::Sendmail
                  def deliver!(*args)
                    Thread.start do
                      super *args
                    end
                  end
                end
                class TmpFile
                  def initialize(*args); end
                  def deliver!(mail)
                    dest_dir = File.join(Rails.root, 'tmp', 'emails')
                    Dir.mkdir(dest_dir) unless File.directory?(dest_dir)
                    File.open(File.join(dest_dir, mail.message_id.gsub(/[<>]/, '') + '.eml'), 'wb') {|f| f.write(mail.encoded) }
                  end
                end
              end
              ActionMailer::Base.add_delivery_method :async_smtp, DeliveryMethods::AsyncSMTP
              ActionMailer::Base.add_delivery_method :async_sendmail, DeliveryMethods::AsyncSendmail
              ActionMailer::Base.add_delivery_method :tmp_file, DeliveryMethods::TmpFile
              # Changes how sent emails are logged
              # Rails doesn't log cc and bcc which is misleading when using bcc only (#12090)
              module ActionMailer
                class LogSubscriber < ActiveSupport::LogSubscriber
                  def deliver(event)
                    recipients = [:to, :cc, :bcc].inject("") do |s, header|
                      r = Array.wrap(event.payload[header])
                      if r.any?
                        s << "\n  #{header}: #{r.join(', ')}"
                      end
                      s
                    end
                    info("\nSent email \"#{event.payload[:subject]}\" (%1.fms)#{recipients}" % event.duration)
                    debug(event.payload[:mail])
                  end
                end
              end
+             # #deliver is deprecated in Rails 4.2
+             # Prevents massive deprecation warnings
+             module ActionMailer
+               class MessageDelivery < Delegator
+                 def deliver
+                   deliver_now
+                 end
+               end
+             end
              module ActionController
                module MimeResponds
                  class Collector
                    def api(&block)
                      any(:xml, :json, &block)
                    end
                  end
                end
              end
              module ActionController
                class Base
                  # Displays an explicit message instead of a NoMethodError exception
                  # when trying to start Redmine with an old session_store.rb
                  # TODO: remove it in a later version
                  def self.session=(*args)
                    $stderr.puts "Please remove config/initializers/session_store.rb and run `rake generate_secret_token`.\n" +
-                     "Setting the session secret with ActionController.session= is no longer supported in Rails 3."
+                     "Setting the session secret with ActionController.session= is no longer supported."
                    exit 1
                  end
                end
              end
-             if Rails::VERSION::MAJOR < 4 && RUBY_VERSION >= "2.1"
-               module ActiveSupport
-                 class HashWithIndifferentAccess
-                   def select(*args, &block)
-                     dup.tap { |hash| hash.select!(*args, &block) }
-                   end
-                   def reject(*args, &block)
-                     dup.tap { |hash| hash.reject!(*args, &block) }
-                   end
-                 end
-                 class OrderedHash
-                   def select(*args, &block)
-                     dup.tap { |hash| hash.select!(*args, &block) }
-                   end
-                   def reject(*args, &block)
-                     dup.tap { |hash| hash.reject!(*args, &block) }
-                   end
-                 end
-               end
-             end

config/routes.rb +14 -10

              # Redmine - project management software
              # Copyright (C) 2006-2015  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.
              Rails.application.routes.draw do
                root :to => 'welcome#index', :as => 'home'
                match 'login', :to => 'account#login', :as => 'signin', :via => [:get, :post]
                match 'logout', :to => 'account#logout', :as => 'signout', :via => [:get, :post]
                match 'account/register', :to => 'account#register', :via => [:get, :post], :as => 'register'
                match 'account/lost_password', :to => 'account#lost_password', :via => [:get, :post], :as => 'lost_password'
                match 'account/activate', :to => 'account#activate', :via => :get
                get 'account/activation_email', :to => 'account#activation_email', :as => 'activation_email'
                match '/news/preview', :controller => 'previews', :action => 'news', :as => 'preview_news', :via => [:get, :post, :put, :patch]
                match '/issues/preview/new/:project_id', :to => 'previews#issue', :as => 'preview_new_issue', :via => [:get, :post, :put, :patch]
                match '/issues/preview/edit/:id', :to => 'previews#issue', :as => 'preview_edit_issue', :via => [:get, :post, :put, :patch]
                match '/issues/preview', :to => 'previews#issue', :as => 'preview_issue', :via => [:get, :post, :put, :patch]
                match 'projects/:id/wiki', :to => 'wikis#edit', :via => :post
                match 'projects/:id/wiki/destroy', :to => 'wikis#destroy', :via => [:get, :post]
                match 'boards/:board_id/topics/new', :to => 'messages#new', :via => [:get, :post], :as => 'new_board_message'
                get 'boards/:board_id/topics/:id', :to => 'messages#show', :as => 'board_message'
                match 'boards/:board_id/topics/quote/:id', :to => 'messages#quote', :via => [:get, :post]
                get 'boards/:board_id/topics/:id/edit', :to => 'messages#edit'
                post 'boards/:board_id/topics/preview', :to => 'messages#preview', :as => 'preview_board_message'
                post 'boards/:board_id/topics/:id/replies', :to => 'messages#reply'
                post 'boards/:board_id/topics/:id/edit', :to => 'messages#edit'
                post 'boards/:board_id/topics/:id/destroy', :to => 'messages#destroy'
                # Misc issue routes. TODO: move into resources
                match '/issues/auto_complete', :to => 'auto_completes#issues', :via => :get, :as => 'auto_complete_issues'
                match '/issues/context_menu', :to => 'context_menus#issues', :as => 'issues_context_menu', :via => [:get, :post]
                match '/issues/changes', :to => 'journals#index', :as => 'issue_changes', :via => :get
                match '/issues/:id/quoted', :to => 'journals#new', :id => /\d+/, :via => :post, :as => 'quoted_issue'
                match '/journals/diff/:id', :to => 'journals#diff', :id => /\d+/, :via => :get
                match '/journals/edit/:id', :to => 'journals#edit', :id => /\d+/, :via => [:get, :post]
                get '/projects/:project_id/issues/gantt', :to => 'gantts#show', :as => 'project_gantt'
                get '/issues/gantt', :to => 'gantts#show'
                get '/projects/:project_id/issues/calendar', :to => 'calendars#show', :as => 'project_calendar'
                get '/issues/calendar', :to => 'calendars#show'
                get 'projects/:id/issues/report', :to => 'reports#issue_report', :as => 'project_issues_report'
                get 'projects/:id/issues/report/:detail', :to => 'reports#issue_report_details', :as => 'project_issues_report_details'
                match 'my/account', :controller => 'my', :action => 'account', :via => [:get, :post]
                match 'my/account/destroy', :controller => 'my', :action => 'destroy', :via => [:get, :post]
                match 'my/page', :controller => 'my', :action => 'page', :via => :get
                match 'my', :controller => 'my', :action => 'index', :via => :get # Redirects to my/page
                match 'my/reset_rss_key', :controller => 'my', :action => 'reset_rss_key', :via => :post
                match 'my/reset_api_key', :controller => 'my', :action => 'reset_api_key', :via => :post
                match 'my/password', :controller => 'my', :action => 'password', :via => [:get, :post]
                match 'my/page_layout', :controller => 'my', :action => 'page_layout', :via => :get
                match 'my/add_block', :controller => 'my', :action => 'add_block', :via => :post
                match 'my/remove_block', :controller => 'my', :action => 'remove_block', :via => :post
                match 'my/order_blocks', :controller => 'my', :action => 'order_blocks', :via => :post
                resources :users do
                  resources :memberships, :controller => 'principal_memberships'
                  resources :email_addresses, :only => [:index, :create, :update, :destroy]
                end
                post 'watchers/watch', :to => 'watchers#watch', :as => 'watch'
                delete 'watchers/watch', :to => 'watchers#unwatch'
                get 'watchers/new', :to => 'watchers#new'
                post 'watchers', :to => 'watchers#create'
                post 'watchers/append', :to => 'watchers#append'
                delete 'watchers', :to => 'watchers#destroy'
                get 'watchers/autocomplete_for_user', :to => 'watchers#autocomplete_for_user'
                # Specific routes for issue watchers API
                post 'issues/:object_id/watchers', :to => 'watchers#create', :object_type => 'issue'
                delete 'issues/:object_id/watchers/:user_id' => 'watchers#destroy', :object_type => 'issue'
                resources :projects do
                  member do
                    get 'settings(/:tab)', :action => 'settings', :as => 'settings'
                    post 'modules'
                    post 'archive'
                    post 'unarchive'
                    post 'close'
                    post 'reopen'
                    match 'copy', :via => [:get, :post]
                  end
                  shallow do
                    resources :memberships, :controller => 'members', :only => [:index, :show, :new, :create, :update, :destroy] do
                      collection do
                        get 'autocomplete'
                      end
                    end
                  end
                  resource :enumerations, :controller => 'project_enumerations', :only => [:update, :destroy]
                  get 'issues/:copy_from/copy', :to => 'issues#new', :as => 'copy_issue'
                  resources :issues, :only => [:index, :new, :create]
                  # issue form update
                  match 'issues/update_form', :controller => 'issues', :action => 'update_form', :via => [:put, :patch, :post], :as => 'issue_form'
                  resources :files, :only => [:index, :new, :create]
                  resources :versions, :except => [:index, :show, :edit, :update, :destroy] do
                    collection do
                      put 'close_completed'
                    end
                  end
                  get 'versions.:format', :to => 'versions#index'
                  get 'roadmap', :to => 'versions#index', :format => false
                  get 'versions', :to => 'versions#index'
                  resources :news, :except => [:show, :edit, :update, :destroy]
                  resources :time_entries, :controller => 'timelog', :except => [:show, :edit, :update, :destroy] do
                    get 'report', :on => :collection
                  end
                  resources :queries, :only => [:new, :create]
                  shallow do
                    resources :issue_categories
                  end
                  resources :documents, :except => [:show, :edit, :update, :destroy]
                  resources :boards
                  shallow do
                    resources :repositories, :except => [:index, :show] do
                      member do
                        match 'committers', :via => [:get, :post]
                      end
                    end
                  end
                  match 'wiki/index', :controller => 'wiki', :action => 'index', :via => :get
                  resources :wiki, :except => [:index, :new, :create], :as => 'wiki_page' do
                    member do
                      get 'rename'
                      post 'rename'
                      get 'history'
                      get 'diff'
                      match 'preview', :via => [:post, :put, :patch]
                      post 'protect'
                      post 'add_attachment'
                    end
                    collection do
                      get 'export'
                      get 'date_index'
                    end
                  end
                  match 'wiki', :controller => 'wiki', :action => 'show', :via => :get
                  get 'wiki/:id/:version', :to => 'wiki#show', :constraints => {:version => /\d+/}
                  delete 'wiki/:id/:version', :to => 'wiki#destroy_version'
                  get 'wiki/:id/:version/annotate', :to => 'wiki#annotate'
                  get 'wiki/:id/:version/diff', :to => 'wiki#diff'
                end
                resources :issues do
                  collection do
                    match 'bulk_edit', :via => [:get, :post]
                    post 'bulk_update'
                  end
                  resources :time_entries, :controller => 'timelog', :except => [:show, :edit, :update, :destroy] do
                    collection do
                      get 'report'
                    end
                  end
                  shallow do
                    resources :relations, :controller => 'issue_relations', :only => [:index, :show, :create, :destroy]
                  end
                end
                match '/issues', :controller => 'issues', :action => 'destroy', :via => :delete
                resources :queries, :except => [:show]
                resources :news, :only => [:index, :show, :edit, :update, :destroy]
                match '/news/:id/comments', :to => 'comments#create', :via => :post
                match '/news/:id/comments/:comment_id', :to => 'comments#destroy', :via => :delete
                resources :versions, :only => [:show, :edit, :update, :destroy] do
                  post 'status_by', :on => :member
                end
                resources :documents, :only => [:show, :edit, :update, :destroy] do
                  post 'add_attachment', :on => :member
                end
                match '/time_entries/context_menu', :to => 'context_menus#time_entries', :as => :time_entries_context_menu, :via => [:get, :post]
                resources :time_entries, :controller => 'timelog', :except => :destroy do
                  collection do
                    get 'report'
                    get 'bulk_edit'
                    post 'bulk_update'
                  end
                end
                match '/time_entries/:id', :to => 'timelog#destroy', :via => :delete, :id => /\d+/
                # TODO: delete /time_entries for bulk deletion
                match '/time_entries/destroy', :to => 'timelog#destroy', :via => :delete
                get 'projects/:id/activity', :to => 'activities#index', :as => :project_activity
                get 'activity', :to => 'activities#index'
                # repositories routes
                get 'projects/:id/repository/:repository_id/statistics', :to => 'repositories#stats'
                get 'projects/:id/repository/:repository_id/graph', :to => 'repositories#graph'
-               get 'projects/:id/repository/:repository_id/changes(/*path(.:ext))',
-                   :to => 'repositories#changes'
+               get 'projects/:id/repository/:repository_id/changes(/*path)',
+                   :to => 'repositories#changes',
+                   :format => false
                get 'projects/:id/repository/:repository_id/revisions/:rev', :to => 'repositories#revision'
                get 'projects/:id/repository/:repository_id/revision', :to => 'repositories#revision'
                post   'projects/:id/repository/:repository_id/revisions/:rev/issues', :to => 'repositories#add_related_issue'
                delete 'projects/:id/repository/:repository_id/revisions/:rev/issues/:issue_id', :to => 'repositories#remove_related_issue'
                get 'projects/:id/repository/:repository_id/revisions', :to => 'repositories#revisions'
-               get 'projects/:id/repository/:repository_id/revisions/:rev/:action(/*path(.:ext))',
+               get 'projects/:id/repository/:repository_id/revisions/:rev/:action(/*path)',
                    :controller => 'repositories',
                    :format => false,
                    :constraints => {
                          :action => /(browse|show|entry|raw|annotate|diff)/,
                          :rev    => /[a-z0-9\.\-_]+/
                        }
                get 'projects/:id/repository/statistics', :to => 'repositories#stats'
                get 'projects/:id/repository/graph', :to => 'repositories#graph'
-               get 'projects/:id/repository/changes(/*path(.:ext))',
-                   :to => 'repositories#changes'
+               get 'projects/:id/repository/changes(/*path)',
+                   :to => 'repositories#changes',
+                   :format => false
                get 'projects/:id/repository/revisions', :to => 'repositories#revisions'
                get 'projects/:id/repository/revisions/:rev', :to => 'repositories#revision'
                get 'projects/:id/repository/revision', :to => 'repositories#revision'
                post   'projects/:id/repository/revisions/:rev/issues', :to => 'repositories#add_related_issue'
                delete 'projects/:id/repository/revisions/:rev/issues/:issue_id', :to => 'repositories#remove_related_issue'
-               get 'projects/:id/repository/revisions/:rev/:action(/*path(.:ext))',
+               get 'projects/:id/repository/revisions/:rev/:action(/*path)',
                    :controller => 'repositories',
                    :format => false,
                    :constraints => {
                          :action => /(browse|show|entry|raw|annotate|diff)/,
                          :rev    => /[a-z0-9\.\-_]+/
                        }
-               get 'projects/:id/repository/:repository_id/:action(/*path(.:ext))',
+               get 'projects/:id/repository/:repository_id/:action(/*path)',
                    :controller => 'repositories',
-                   :action => /(browse|show|entry|raw|changes|annotate|diff)/
-               get 'projects/:id/repository/:action(/*path(.:ext))',
+                   :action => /(browse|show|entry|raw|changes|annotate|diff)/,
+                   :format => false
+               get 'projects/:id/repository/:action(/*path)',
                    :controller => 'repositories',
-                   :action => /(browse|show|entry|raw|changes|annotate|diff)/
+                   :action => /(browse|show|entry|raw|changes|annotate|diff)/,
+                   :format => false
                get 'projects/:id/repository/:repository_id', :to => 'repositories#show', :path => nil
                get 'projects/:id/repository', :to => 'repositories#show', :path => nil
                # additional routes for having the file name at the end of url
                get 'attachments/:id/:filename', :to => 'attachments#show', :id => /\d+/, :filename => /.*/, :as => 'named_attachment'
                get 'attachments/download/:id/:filename', :to => 'attachments#download', :id => /\d+/, :filename => /.*/, :as => 'download_named_attachment'
                get 'attachments/download/:id', :to => 'attachments#download', :id => /\d+/
                get 'attachments/thumbnail/:id(/:size)', :to => 'attachments#thumbnail', :id => /\d+/, :size => /\d+/, :as => 'thumbnail'
                resources :attachments, :only => [:show, :destroy]
                get 'attachments/:object_type/:object_id/edit', :to => 'attachments#edit', :as => :object_attachments_edit
                patch 'attachments/:object_type/:object_id', :to => 'attachments#update', :as => :object_attachments
                resources :groups do
                  resources :memberships, :controller => 'principal_memberships'
                  member do
                    get 'autocomplete_for_user'
                  end
                end
                get 'groups/:id/users/new', :to => 'groups#new_users', :id => /\d+/, :as => 'new_group_users'
                post 'groups/:id/users', :to => 'groups#add_users', :id => /\d+/, :as => 'group_users'
                delete 'groups/:id/users/:user_id', :to => 'groups#remove_user', :id => /\d+/, :as => 'group_user'
                resources :trackers, :except => :show do
                  collection do
                    match 'fields', :via => [:get, :post]
                  end
                end
                resources :issue_statuses, :except => :show do
                  collection do
                    post 'update_issue_done_ratio'
                  end
                end
                resources :custom_fields, :except => :show
                resources :roles do
                  collection do
                    match 'permissions', :via => [:get, :post]
                  end
                end
                resources :enumerations, :except => :show
                match 'enumerations/:type', :to => 'enumerations#index', :via => :get
                get 'projects/:id/search', :controller => 'search', :action => 'index'
                get 'search', :controller => 'search', :action => 'index'
                match 'mail_handler', :controller => 'mail_handler', :action => 'index', :via => :post
                match 'admin', :controller => 'admin', :action => 'index', :via => :get
                match 'admin/projects', :controller => 'admin', :action => 'projects', :via => :get
                match 'admin/plugins', :controller => 'admin', :action => 'plugins', :via => :get
                match 'admin/info', :controller => 'admin', :action => 'info', :via => :get
                match 'admin/test_email', :controller => 'admin', :action => 'test_email', :via => :get
                match 'admin/default_configuration', :controller => 'admin', :action => 'default_configuration', :via => :post
                resources :auth_sources do
                  member do
                    get 'test_connection', :as => 'try_connection'
                  end
                  collection do
                    get 'autocomplete_for_new_user'
                  end
                end
                match 'workflows', :controller => 'workflows', :action => 'index', :via => :get
                match 'workflows/edit', :controller => 'workflows', :action => 'edit', :via => [:get, :post]
                match 'workflows/permissions', :controller => 'workflows', :action => 'permissions', :via => [:get, :post]
                match 'workflows/copy', :controller => 'workflows', :action => 'copy', :via => [:get, :post]
                match 'settings', :controller => 'settings', :action => 'index', :via => :get
                match 'settings/edit', :controller => 'settings', :action => 'edit', :via => [:get, :post]
                match 'settings/plugin/:id', :controller => 'settings', :action => 'plugin', :via => [:get, :post], :as => 'plugin_settings'
                match 'sys/projects', :to => 'sys#projects', :via => :get
                match 'sys/projects/:id/repository', :to => 'sys#create_project_repository', :via => :post
                match 'sys/fetch_changesets', :to => 'sys#fetch_changesets', :via => [:get, :post]
                match 'uploads', :to => 'attachments#upload', :via => :post
                get 'robots.txt', :to => 'welcome#robots'
                Dir.glob File.expand_path("plugins/*", Rails.root) do |plugin_dir|
                  file = File.join(plugin_dir, "config/routes.rb")
                  if File.exists?(file)
                    begin
                      instance_eval File.read(file)
                    rescue Exception => e
                      puts "An error occurred while loading the routes definition of #{File.basename(plugin_dir)} plugin (#{file}): #{e.message}."
                      exit 1
                    end
                  end
                end
              end

lib/tasks/initializers.rake +1 -1

              desc 'Generates a secret token for the application.'
              file 'config/initializers/secret_token.rb' do
                path = File.join(Rails.root, 'config', 'initializers', 'secret_token.rb')
                secret = SecureRandom.hex(40)
                File.open(path, 'w') do |f|
                  f.write <<"EOF"
              # This file was generated by 'rake generate_secret_token', and should
              # not be made visible to public.
              # If you have a load-balancing Redmine cluster, you will need to use the
              # same version of this file on each machine. And be sure to restart your
              # server when you modify this file.
              #
              # Your secret key for verifying cookie session data integrity. If you
              # change this key, all old sessions will become invalid! Make sure the
              # secret is at least 30 characters and all random, no regular words or
              # you'll be exposed to dictionary attacks.
-             RedmineApp::Application.config.secret_token = '#{secret}'
+             RedmineApp::Application.config.secret_key_base = '#{secret}'
              EOF
                end
              end
              desc 'Generates a secret token for the application.'
              task :generate_secret_token => ['config/initializers/secret_token.rb']

lib/tasks/testing.rake +1 -1

              namespace :test do
                desc 'Measures test coverage'
                task :coverage do
                  rm_f "coverage"
                  ENV["COVERAGE"] = "1"
                  Rake::Task["test"].invoke
                end
                desc 'Run unit and functional scm tests'
                task :scm do
                  errors = %w(test:scm:units test:scm:functionals).collect do |task|
                    begin
                      Rake::Task[task].invoke
                      nil
                    rescue => e
                      task
                    end
                  end.compact
                  abort "Errors running #{errors.to_sentence(:locale => :en)}!" if errors.any?
                end
                namespace :scm do
                  namespace :setup do
                    desc "Creates directory for test repositories"
                    task :create_dir => :environment do
                      FileUtils.mkdir_p Rails.root + '/tmp/test'
                    end
                    supported_scms = [:subversion, :cvs, :bazaar, :mercurial, :git, :darcs, :filesystem]
                    desc "Creates a test subversion repository"
                    task :subversion => :create_dir do
                      repo_path = "tmp/test/subversion_repository"
                      unless File.exists?(repo_path)
                        system "svnadmin create #{repo_path}"
                        system "gunzip < test/fixtures/repositories/subversion_repository.dump.gz | svnadmin load #{repo_path}"
                      end
                    end
                    desc "Creates a test mercurial repository"
                    task :mercurial => :create_dir do
                      repo_path = "tmp/test/mercurial_repository"
                      unless File.exists?(repo_path)
                        bundle_path = "test/fixtures/repositories/mercurial_repository.hg"
                        system "hg init #{repo_path}"
                        system "hg -R #{repo_path} pull #{bundle_path}"
                      end
                    end
                    def extract_tar_gz(prefix)
                      unless File.exists?("tmp/test/#{prefix}_repository")
                        # system "gunzip < test/fixtures/repositories/#{prefix}_repository.tar.gz | tar -xv -C tmp/test"
                        system "tar -xvz -C tmp/test -f test/fixtures/repositories/#{prefix}_repository.tar.gz"
                      end
                    end
                    (supported_scms - [:subversion, :mercurial]).each do |scm|
                      desc "Creates a test #{scm} repository"
                      task scm => :create_dir do
                        extract_tar_gz(scm)
                      end
                    end
                    desc "Creates all test repositories"
                    task :all => supported_scms
                  end
                  desc "Updates installed test repositories"
                  task :update => :environment do
                    require 'fileutils'
                    Dir.glob("tmp/test/*_repository").each do |dir|
                      next unless File.basename(dir) =~ %r{^(.+)_repository$} && File.directory?(dir)
                      scm = $1
                      next unless fixture = Dir.glob("test/fixtures/repositories/#{scm}_repository.*").first
                      next if File.stat(dir).ctime > File.stat(fixture).mtime
                      FileUtils.rm_rf dir
                      Rake::Task["test:scm:setup:#{scm}"].execute
                    end
                  end
                  Rake::TestTask.new(:units => "db:test:prepare") do |t|
                    t.libs << "test"
                    t.verbose = true
                    t.test_files = FileList['test/unit/repository*_test.rb'] + FileList['test/unit/lib/redmine/scm/**/*_test.rb']
                  end
                  Rake::Task['test:scm:units'].comment = "Run the scm unit tests"
                  Rake::TestTask.new(:functionals => "db:test:prepare") do |t|
                    t.libs << "test"
                    t.verbose = true
                    t.test_files = FileList['test/functional/repositories*_test.rb']
                  end
                  Rake::Task['test:scm:functionals'].comment = "Run the scm functional tests"
                end
                Rake::TestTask.new(:routing) do |t|
                  t.libs << "test"
                  t.verbose = true
                  t.test_files = FileList['test/integration/routing/*_test.rb'] + FileList['test/integration/api_test/*_routing_test.rb']
                end
                Rake::Task['test:routing'].comment = "Run the routing tests"
                Rake::TestTask.new(:ui => "db:test:prepare") do |t|
                  t.libs << "test"
                  t.verbose = true
-                 t.test_files = FileList['test/ui/**/*_test.rb']
+                 t.test_files = FileList['test/ui/**/*_test_ui.rb']
                end
                Rake::Task['test:ui'].comment = "Run the UI tests with Capybara (PhantomJS listening on port 4444 is required)"
              end

test/extra/redmine_pm/repository_git_test_pm.rb ~~test/extra/redmine_pm/repository_git_test.rb~~ renamed 0 0

NO CONTENT: file renamed from test/extra/redmine_pm/repository_git_test.rb to test/extra/redmine_pm/repository_git_test_pm.rb

test/extra/redmine_pm/repository_subversion_test_pm.rb ~~test/extra/redmine_pm/repository_subversion_test.rb~~ renamed 0 0

NO CONTENT: file renamed from test/extra/redmine_pm/repository_subversion_test.rb to test/extra/redmine_pm/repository_subversion_test_pm.rb

test/functional/activities_controller_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 ActivitiesControllerTest < ActionController::TestCase
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :enumerations, :users, :issue_categories,
                         :projects_trackers,
                         :roles,
                         :member_roles,
                         :members,
                         :groups_users,
                         :enabled_modules,
                         :journals, :journal_details
                def test_project_index
                  get :index, :id => 1, :with_subprojects => 0
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:events_by_day)
                  assert_select 'h3', :text => /#{2.days.ago.to_date.day}/
                  assert_select 'dl dt.issue-edit a', :text => /(#{IssueStatus.find(2).name})/
                end
                def test_project_index_with_invalid_project_id_should_respond_404
                  get :index, :id => 299
                  assert_response 404
                end
                def test_previous_project_index
                  get :index, :id => 1, :from => 2.days.ago.to_date
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:events_by_day)
                  assert_select 'h3', :text => /#{3.days.ago.to_date.day}/
                  assert_select 'dl dt.issue a', :text => /Cannot print recipes/
                end
                def test_global_index
                  @request.session[:user_id] = 1
                  get :index
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:events_by_day)
                  i5 = Issue.find(5)
                  d5 = User.find(1).time_to_date(i5.created_on)
                  assert_select 'h3', :text => /#{d5.day}/
                  assert_select 'dl dt.issue a', :text => /Subproject issue/
                end
                def test_user_index
                  @request.session[:user_id] = 1
                  get :index, :user_id => 2
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:events_by_day)
                  assert_select 'h2 a[href="/users/2"]', :text => 'John Smith'
                  i1 = Issue.find(1)
                  d1 = User.find(1).time_to_date(i1.created_on)
                  assert_select 'h3', :text => /#{d1.day}/
                  assert_select 'dl dt.issue a', :text => /Cannot print recipes/
                end
                def test_user_index_with_invalid_user_id_should_respond_404
                  get :index, :user_id => 299
                  assert_response 404
                end
                def test_index_atom_feed
                  get :index, :format => 'atom', :with_subprojects => 0
                  assert_response :success
                  assert_template 'common/feed'
                  assert_select 'feed' do
                    assert_select 'link[rel=self][href=?]', 'http://test.host/activity.atom?with_subprojects=0'
                    assert_select 'link[rel=alternate][href=?]', 'http://test.host/activity?with_subprojects=0'
                    assert_select 'entry' do
                      assert_select 'link[href=?]', 'http://test.host/issues/11'
                    end
                  end
                end
                def test_index_atom_feed_with_explicit_selection
                  get :index, :format => 'atom', :with_subprojects => 0,
                    :show_changesets => 1,
                    :show_documents => 1,
                    :show_files => 1,
                    :show_issues => 1,
                    :show_messages => 1,
                    :show_news => 1,
                    :show_time_entries => 1,
                    :show_wiki_edits => 1
                  assert_response :success
                  assert_template 'common/feed'
                  assert_select 'feed' do
-                   assert_select 'link[rel=self][href=?]', 'http://test.host/activity.atom?show_changesets=1&amp;show_documents=1&amp;show_files=1&amp;show_issues=1&amp;show_messages=1&amp;show_news=1&amp;show_time_entries=1&amp;show_wiki_edits=1&amp;with_subprojects=0'
-                   assert_select 'link[rel=alternate][href=?]', 'http://test.host/activity?show_changesets=1&amp;show_documents=1&amp;show_files=1&amp;show_issues=1&amp;show_messages=1&amp;show_news=1&amp;show_time_entries=1&amp;show_wiki_edits=1&amp;with_subprojects=0'
+                   assert_select 'link[rel=self][href=?]', 'http://test.host/activity.atom?show_changesets=1&show_documents=1&show_files=1&show_issues=1&show_messages=1&show_news=1&show_time_entries=1&show_wiki_edits=1&with_subprojects=0'
+                   assert_select 'link[rel=alternate][href=?]', 'http://test.host/activity?show_changesets=1&show_documents=1&show_files=1&show_issues=1&show_messages=1&show_news=1&show_time_entries=1&show_wiki_edits=1&with_subprojects=0'
                    assert_select 'entry' do
                      assert_select 'link[href=?]', 'http://test.host/issues/11'
                    end
                  end
                end
                def test_index_atom_feed_with_one_item_type
                  with_settings :default_language => 'en' do
                    get :index, :format => 'atom', :show_issues => '1'
                    assert_response :success
                    assert_template 'common/feed'
                    assert_select 'title', :text => /Issues/
                  end
                end
                def test_index_atom_feed_with_user
                  get :index, :user_id => 2, :format => 'atom'
                  assert_response :success
                  assert_template 'common/feed'
                  assert_select 'title', :text => "Redmine: #{User.find(2).name}"
                end
                def test_index_should_show_private_notes_with_permission_only
                  journal = Journal.create!(:journalized => Issue.find(2), :notes => 'Private notes with searchkeyword', :private_notes => true)
                  @request.session[:user_id] = 2
                  get :index
                  assert_response :success
                  assert_include journal, assigns(:events_by_day).values.flatten
                  Role.find(1).remove_permission! :view_private_notes
                  get :index
                  assert_response :success
                  assert_not_include journal, assigns(:events_by_day).values.flatten
                end
              end

test/functional/auth_sources_controller_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 AuthSourcesControllerTest < ActionController::TestCase
                fixtures :users, :auth_sources
                def setup
                  @request.session[:user_id] = 1
                end
                def test_index
                  get :index
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:auth_sources)
                end
                def test_new
                  get :new
                  assert_response :success
                  assert_template 'new'
                  source = assigns(:auth_source)
                  assert_equal AuthSourceLdap, source.class
                  assert source.new_record?
                  assert_select 'form#auth_source_form' do
                    assert_select 'input[name=type][value=AuthSourceLdap]'
                    assert_select 'input[name=?]', 'auth_source[host]'
                  end
                end
                def test_new_with_invalid_type_should_respond_with_404
                  get :new, :type => 'foo'
                  assert_response 404
                end
                def test_create
                  assert_difference 'AuthSourceLdap.count' do
                    post :create, :type => 'AuthSourceLdap', :auth_source => {:name => 'Test', :host => '127.0.0.1', :port => '389', :attr_login => 'cn'}
                    assert_redirected_to '/auth_sources'
                  end
                  source = AuthSourceLdap.order('id DESC').first
                  assert_equal 'Test', source.name
                  assert_equal '127.0.0.1', source.host
                  assert_equal 389, source.port
                  assert_equal 'cn', source.attr_login
                end
                def test_create_with_failure
                  assert_no_difference 'AuthSourceLdap.count' do
                    post :create, :type => 'AuthSourceLdap',
                                  :auth_source => {:name => 'Test', :host => '',
                                                   :port => '389', :attr_login => 'cn'}
                    assert_response :success
                    assert_template 'new'
                  end
                  assert_select_error /host cannot be blank/i
                end
                def test_edit
                  get :edit, :id => 1
                  assert_response :success
                  assert_template 'edit'
                  assert_select 'form#auth_source_form' do
                    assert_select 'input[name=?]', 'auth_source[host]'
                  end
                end
                def test_edit_should_not_contain_password
                  AuthSource.find(1).update_column :account_password, 'secret'
                  get :edit, :id => 1
                  assert_response :success
                  assert_select 'input[value=secret]', 0
-                 assert_select 'input[name=dummy_password][value=?]', /x+/
+                 assert_select 'input[name=dummy_password][value^=xxxxxx]'
                end
                def test_edit_invalid_should_respond_with_404
                  get :edit, :id => 99
                  assert_response 404
                end
                def test_update
                  put :update, :id => 1,
                               :auth_source => {:name => 'Renamed', :host => '192.168.0.10',
                                                :port => '389', :attr_login => 'uid'}
                  assert_redirected_to '/auth_sources'
                  source = AuthSourceLdap.find(1)
                  assert_equal 'Renamed', source.name
                  assert_equal '192.168.0.10', source.host
                end
                def test_update_with_failure
                  put :update, :id => 1,
                               :auth_source => {:name => 'Renamed', :host => '',
                                                :port => '389', :attr_login => 'uid'}
                  assert_response :success
                  assert_template 'edit'
                  assert_select_error /host cannot be blank/i
                end
                def test_destroy
                  assert_difference 'AuthSourceLdap.count', -1 do
                    delete :destroy, :id => 1
                    assert_redirected_to '/auth_sources'
                  end
                end
                def test_destroy_auth_source_in_use
                  User.find(2).update_attribute :auth_source_id, 1
                  assert_no_difference 'AuthSourceLdap.count' do
                    delete :destroy, :id => 1
                    assert_redirected_to '/auth_sources'
                  end
                end
                def test_test_connection
                  AuthSourceLdap.any_instance.stubs(:test_connection).returns(true)
                  get :test_connection, :id => 1
                  assert_redirected_to '/auth_sources'
                  assert_not_nil flash[:notice]
                  assert_match /successful/i, flash[:notice]
                end
                def test_test_connection_with_failure
                  AuthSourceLdap.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError.new("Something went wrong"))
                  get :test_connection, :id => 1
                  assert_redirected_to '/auth_sources'
                  assert_not_nil flash[:error]
                  assert_include 'Something went wrong', flash[:error]
                end
                def test_autocomplete_for_new_user
                  AuthSource.expects(:search).with('foo').returns([
                    {:login => 'foo1', :firstname => 'John', :lastname => 'Smith', :mail => 'foo1@example.net', :auth_source_id => 1},
                    {:login => 'Smith', :firstname => 'John', :lastname => 'Doe', :mail => 'foo2@example.net', :auth_source_id => 1}
                  ])
                  get :autocomplete_for_new_user, :term => 'foo'
                  assert_response :success
                  assert_equal 'application/json', response.content_type
                  json = ActiveSupport::JSON.decode(response.body)
                  assert_kind_of Array, json
                  assert_equal 2, json.size
                  assert_equal 'foo1', json.first['value']
                  assert_equal 'foo1 (John Smith)', json.first['label']
                end
              end

test/functional/boards_controller_test.rb +5 -1

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 BoardsControllerTest < ActionController::TestCase
                fixtures :projects, :users, :members, :member_roles, :roles, :boards, :messages, :enabled_modules
                def setup
                  User.current = nil
                end
                def test_index
                  get :index, :project_id => 1
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:boards)
                  assert_not_nil assigns(:project)
                end
                def test_index_not_found
                  get :index, :project_id => 97
                  assert_response 404
                end
                def test_index_should_show_messages_if_only_one_board
                  Project.find(1).boards.slice(1..-1).each(&:destroy)
                  get :index, :project_id => 1
                  assert_response :success
                  assert_template 'show'
                  assert_not_nil assigns(:topics)
                end
                def test_show
                  get :show, :project_id => 1, :id => 1
                  assert_response :success
                  assert_template 'show'
                  assert_not_nil assigns(:board)
                  assert_not_nil assigns(:project)
                  assert_not_nil assigns(:topics)
                end
                def test_show_should_display_sticky_messages_first
                  Message.update_all(:sticky => 0)
                  Message.where({:id => 1}).update_all({:sticky => 1})
                  get :show, :project_id => 1, :id => 1
                  assert_response :success
                  topics = assigns(:topics)
                  assert_not_nil topics
                  assert topics.size > 1, "topics size was #{topics.size}"
                  assert topics.first.sticky?
                  assert topics.first.updated_on < topics.second.updated_on
                end
                def test_show_should_display_message_with_last_reply_first
                  Message.update_all(:sticky => 0)
                  # Reply to an old topic
                  old_topic = Message.where(:board_id => 1, :parent_id => nil).order('created_on ASC').first
                  reply = Message.new(:board_id => 1, :subject => 'New reply', :content => 'New reply', :author_id => 2)
                  old_topic.children << reply
                  get :show, :project_id => 1, :id => 1
                  assert_response :success
                  topics = assigns(:topics)
                  assert_not_nil topics
                  assert_equal old_topic, topics.first
                end
                def test_show_with_permission_should_display_the_new_message_form
                  @request.session[:user_id] = 2
                  get :show, :project_id => 1, :id => 1
                  assert_response :success
                  assert_template 'show'
                  assert_select 'form#message-form' do
                    assert_select 'input[name=?]', 'message[subject]'
                  end
                end
                def test_show_atom
                  get :show, :project_id => 1, :id => 1, :format => 'atom'
                  assert_response :success
                  assert_template 'common/feed'
                  assert_not_nil assigns(:board)
                  assert_not_nil assigns(:project)
                  assert_not_nil assigns(:messages)
                end
                def test_show_not_found
                  get :index, :project_id => 1, :id => 97
                  assert_response 404
                end
                def test_new
                  @request.session[:user_id] = 2
                  get :new, :project_id => 1
                  assert_response :success
                  assert_template 'new'
                  assert_select 'select[name=?]', 'board[parent_id]' do
                    assert_select 'option', (Project.find(1).boards.size + 1)
-                   assert_select 'option[value=""]', :text => '&nbsp;'
+                   assert_select 'option[value=""]'
                    assert_select 'option[value="1"]', :text => 'Help'
                  end
+                 # &nbsp; replaced by nokogiri, not easy to test in DOM assertions
+                 assert_not_include '<option value=""></option>', response.body
+                 assert_include '<option value="">&nbsp;</option>', response.body
                end
                def test_new_without_project_boards
                  Project.find(1).boards.delete_all
                  @request.session[:user_id] = 2
                  get :new, :project_id => 1
                  assert_response :success
                  assert_template 'new'
                  assert_select 'select[name=?]', 'board[parent_id]', 0
                end
                def test_create
                  @request.session[:user_id] = 2
                  assert_difference 'Board.count' do
                    post :create, :project_id => 1, :board => { :name => 'Testing', :description => 'Testing board creation'}
                  end
                  assert_redirected_to '/projects/ecookbook/settings/boards'
                  board = Board.order('id DESC').first
                  assert_equal 'Testing', board.name
                  assert_equal 'Testing board creation', board.description
                end
                def test_create_with_parent
                  @request.session[:user_id] = 2
                  assert_difference 'Board.count' do
                    post :create, :project_id => 1, :board => { :name => 'Testing', :description => 'Testing', :parent_id => 2}
                  end
                  assert_redirected_to '/projects/ecookbook/settings/boards'
                  board = Board.order('id DESC').first
                  assert_equal Board.find(2), board.parent
                end
                def test_create_with_failure
                  @request.session[:user_id] = 2
                  assert_no_difference 'Board.count' do
                    post :create, :project_id => 1, :board => { :name => '', :description => 'Testing board creation'}
                  end
                  assert_response :success
                  assert_template 'new'
                end
                def test_edit
                  @request.session[:user_id] = 2
                  get :edit, :project_id => 1, :id => 2
                  assert_response :success
                  assert_template 'edit'
                end
                def test_edit_with_parent
                  board = Board.generate!(:project_id => 1, :parent_id => 2)
                  @request.session[:user_id] = 2
                  get :edit, :project_id => 1, :id => board.id
                  assert_response :success
                  assert_template 'edit'
                  assert_select 'select[name=?]', 'board[parent_id]' do
                    assert_select 'option[value="2"][selected=selected]'
                  end
                end
                def test_update
                  @request.session[:user_id] = 2
                  assert_no_difference 'Board.count' do
                    put :update, :project_id => 1, :id => 2, :board => { :name => 'Testing', :description => 'Testing board update'}
                  end
                  assert_redirected_to '/projects/ecookbook/settings/boards'
                  assert_equal 'Testing', Board.find(2).name
                end
                def test_update_position
                  @request.session[:user_id] = 2
                  put :update, :project_id => 1, :id => 2, :board => { :move_to => 'highest'}
                  assert_redirected_to '/projects/ecookbook/settings/boards'
                  board = Board.find(2)
                  assert_equal 1, board.position
                end
                def test_update_with_failure
                  @request.session[:user_id] = 2
                  put :update, :project_id => 1, :id => 2, :board => { :name => '', :description => 'Testing board update'}
                  assert_response :success
                  assert_template 'edit'
                end
                def test_destroy
                  @request.session[:user_id] = 2
                  assert_difference 'Board.count', -1 do
                    delete :destroy, :project_id => 1, :id => 2
                  end
                  assert_redirected_to '/projects/ecookbook/settings/boards'
                  assert_nil Board.find_by_id(2)
                end
              end

test/functional/context_menus_controller_test.rb +34 -34

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 ContextMenusControllerTest < ActionController::TestCase
                fixtures :projects,
                         :trackers,
                         :projects_trackers,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules,
                         :workflows,
                         :journals, :journal_details,
                         :versions,
                         :issues, :issue_statuses, :issue_categories,
                         :users,
                         :enumerations,
                         :time_entries
                def test_context_menu_one_issue
                  @request.session[:user_id] = 2
                  get :issues, :ids => [1]
                  assert_response :success
                  assert_template 'context_menus/issues'
                  assert_select 'a.icon-edit[href=?]', '/issues/1/edit', :text => 'Edit'
                  assert_select 'a.icon-copy[href=?]', '/projects/ecookbook/issues/1/copy', :text => 'Copy'
                  assert_select 'a.icon-del[href=?]', '/issues?ids%5B%5D=1', :text => 'Delete'
                  # Statuses
-                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bstatus_id%5D=5', :text => 'Closed'
-                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bpriority_id%5D=8', :text => 'Immediate'
+                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&issue%5Bstatus_id%5D=5', :text => 'Closed'
+                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&issue%5Bpriority_id%5D=8', :text => 'Immediate'
                  # No inactive priorities
                  assert_select 'a', :text => /Inactive Priority/, :count => 0
                  # Versions
-                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bfixed_version_id%5D=3', :text => '2.0'
-                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bfixed_version_id%5D=4', :text => 'eCookbook Subproject 1 - 2.0'
+                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&issue%5Bfixed_version_id%5D=3', :text => '2.0'
+                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&issue%5Bfixed_version_id%5D=4', :text => 'eCookbook Subproject 1 - 2.0'
                  # Assignees
-                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bassigned_to_id%5D=3', :text => 'Dave Lopper'
+                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&issue%5Bassigned_to_id%5D=3', :text => 'Dave Lopper'
                end
                def test_context_menu_one_issue_by_anonymous
                  with_settings :default_language => 'en' do
                    get :issues, :ids => [1]
                    assert_response :success
                    assert_template 'context_menus/issues'
                    assert_select 'a.icon-del.disabled[href="#"]', :text => 'Delete'
                  end
                end
                def test_context_menu_multiple_issues_of_same_project
                  @request.session[:user_id] = 2
                  get :issues, :ids => [1, 2]
                  assert_response :success
                  assert_template 'context_menus/issues'
                  assert_not_nil assigns(:issues)
                  assert_equal [1, 2], assigns(:issues).map(&:id).sort
-                 ids = assigns(:issues).map(&:id).sort.map {|i| "ids%5B%5D=#{i}"}.join('&amp;')
+                 ids = assigns(:issues).map(&:id).sort.map {|i| "ids%5B%5D=#{i}"}.join('&')
                  assert_select 'a.icon-edit[href=?]', "/issues/bulk_edit?#{ids}", :text => 'Edit'
-                 assert_select 'a.icon-copy[href=?]', "/issues/bulk_edit?copy=1&amp;#{ids}", :text => 'Copy'
+                 assert_select 'a.icon-copy[href=?]', "/issues/bulk_edit?copy=1&#{ids}", :text => 'Copy'
                  assert_select 'a.icon-del[href=?]', "/issues?#{ids}", :text => 'Delete'
-                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&amp;issue%5Bstatus_id%5D=5", :text => 'Closed'
-                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&amp;issue%5Bpriority_id%5D=8", :text => 'Immediate'
-                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&amp;issue%5Bassigned_to_id%5D=3", :text => 'Dave Lopper'
+                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&issue%5Bstatus_id%5D=5", :text => 'Closed'
+                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&issue%5Bpriority_id%5D=8", :text => 'Immediate'
+                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&issue%5Bassigned_to_id%5D=3", :text => 'Dave Lopper'
                end
                def test_context_menu_multiple_issues_of_different_projects
                  @request.session[:user_id] = 2
                  get :issues, :ids => [1, 2, 6]
                  assert_response :success
                  assert_template 'context_menus/issues'
                  assert_not_nil assigns(:issues)
                  assert_equal [1, 2, 6], assigns(:issues).map(&:id).sort
-                 ids = assigns(:issues).map(&:id).sort.map {|i| "ids%5B%5D=#{i}"}.join('&amp;')
+                 ids = assigns(:issues).map(&:id).sort.map {|i| "ids%5B%5D=#{i}"}.join('&')
                  assert_select 'a.icon-edit[href=?]', "/issues/bulk_edit?#{ids}", :text => 'Edit'
                  assert_select 'a.icon-del[href=?]', "/issues?#{ids}", :text => 'Delete'
-                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&amp;issue%5Bstatus_id%5D=5", :text => 'Closed'
-                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&amp;issue%5Bpriority_id%5D=8", :text => 'Immediate'
-                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&amp;issue%5Bassigned_to_id%5D=2", :text => 'John Smith'
+                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&issue%5Bstatus_id%5D=5", :text => 'Closed'
+                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&issue%5Bpriority_id%5D=8", :text => 'Immediate'
+                 assert_select 'a[href=?]', "/issues/bulk_update?#{ids}&issue%5Bassigned_to_id%5D=2", :text => 'John Smith'
                end
                def test_context_menu_should_include_list_custom_fields
                  field = IssueCustomField.create!(:name => 'List', :field_format => 'list',
                    :possible_values => ['Foo', 'Bar'], :is_for_all => true, :tracker_ids => [1, 2, 3])
                  @request.session[:user_id] = 2
                  get :issues, :ids => [1]
                  assert_select "li.cf_#{field.id}" do
-                   assert_select 'a[href=#]', :text => 'List'
+                   assert_select 'a[href="#"]', :text => 'List'
                    assert_select 'ul' do
                      assert_select 'a', 3
-                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bcustom_field_values%5D%5B#{field.id}%5D=Foo", :text => 'Foo'
-                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bcustom_field_values%5D%5B#{field.id}%5D=__none__", :text => 'none'
+                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&issue%5Bcustom_field_values%5D%5B#{field.id}%5D=Foo", :text => 'Foo'
+                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&issue%5Bcustom_field_values%5D%5B#{field.id}%5D=__none__", :text => 'none'
                    end
                  end
                end
                def test_context_menu_should_not_include_null_value_for_required_custom_fields
                  field = IssueCustomField.create!(:name => 'List', :is_required => true, :field_format => 'list',
                    :possible_values => ['Foo', 'Bar'], :is_for_all => true, :tracker_ids => [1, 2, 3])
                  @request.session[:user_id] = 2
                  get :issues, :ids => [1, 2]
                  assert_select "li.cf_#{field.id}" do
-                   assert_select 'a[href=#]', :text => 'List'
+                   assert_select 'a[href="#"]', :text => 'List'
                    assert_select 'ul' do
                      assert_select 'a', 2
                      assert_select 'a', :text => 'none', :count => 0
                    end
                  end
                end
                def test_context_menu_on_single_issue_should_select_current_custom_field_value
                  field = IssueCustomField.create!(:name => 'List', :field_format => 'list',
                    :possible_values => ['Foo', 'Bar'], :is_for_all => true, :tracker_ids => [1, 2, 3])
                  issue = Issue.find(1)
                  issue.custom_field_values = {field.id => 'Bar'}
                  issue.save!
                  @request.session[:user_id] = 2
                  get :issues, :ids => [1]
                  assert_select "li.cf_#{field.id}" do
-                   assert_select 'a[href=#]', :text => 'List'
+                   assert_select 'a[href="#"]', :text => 'List'
                    assert_select 'ul' do
                      assert_select 'a', 3
                      assert_select 'a.icon-checked', :text => 'Bar'
                    end
                  end
                end
                def test_context_menu_should_include_bool_custom_fields
                  field = IssueCustomField.create!(:name => 'Bool', :field_format => 'bool',
                    :is_for_all => true, :tracker_ids => [1, 2, 3])
                  @request.session[:user_id] = 2
                  get :issues, :ids => [1]
                  assert_select "li.cf_#{field.id}" do
-                   assert_select 'a[href=#]', :text => 'Bool'
+                   assert_select 'a[href="#"]', :text => 'Bool'
                    assert_select 'ul' do
                      assert_select 'a', 3
-                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bcustom_field_values%5D%5B#{field.id}%5D=0", :text => 'No'
-                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bcustom_field_values%5D%5B#{field.id}%5D=1", :text => 'Yes'
-                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bcustom_field_values%5D%5B#{field.id}%5D=__none__", :text => 'none'
+                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&issue%5Bcustom_field_values%5D%5B#{field.id}%5D=0", :text => 'No'
+                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&issue%5Bcustom_field_values%5D%5B#{field.id}%5D=1", :text => 'Yes'
+                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&issue%5Bcustom_field_values%5D%5B#{field.id}%5D=__none__", :text => 'none'
                    end
                  end
                end
                def test_context_menu_should_include_user_custom_fields
                  field = IssueCustomField.create!(:name => 'User', :field_format => 'user',
                    :is_for_all => true, :tracker_ids => [1, 2, 3])
                  @request.session[:user_id] = 2
                  get :issues, :ids => [1]
                  assert_select "li.cf_#{field.id}" do
-                   assert_select 'a[href=#]', :text => 'User'
+                   assert_select 'a[href="#"]', :text => 'User'
                    assert_select 'ul' do
                      assert_select 'a', Project.find(1).members.count + 1
-                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bcustom_field_values%5D%5B#{field.id}%5D=2", :text => 'John Smith'
-                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bcustom_field_values%5D%5B#{field.id}%5D=__none__", :text => 'none'
+                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&issue%5Bcustom_field_values%5D%5B#{field.id}%5D=2", :text => 'John Smith'
+                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&issue%5Bcustom_field_values%5D%5B#{field.id}%5D=__none__", :text => 'none'
                    end
                  end
                end
                def test_context_menu_should_include_version_custom_fields
                  field = IssueCustomField.create!(:name => 'Version', :field_format => 'version', :is_for_all => true, :tracker_ids => [1, 2, 3])
                  @request.session[:user_id] = 2
                  get :issues, :ids => [1]
                  assert_select "li.cf_#{field.id}" do
-                   assert_select 'a[href=#]', :text => 'Version'
+                   assert_select 'a[href="#"]', :text => 'Version'
                    assert_select 'ul' do
                      assert_select 'a', Project.find(1).shared_versions.count + 1
-                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bcustom_field_values%5D%5B#{field.id}%5D=3", :text => '2.0'
-                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bcustom_field_values%5D%5B#{field.id}%5D=__none__", :text => 'none'
+                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&issue%5Bcustom_field_values%5D%5B#{field.id}%5D=3", :text => '2.0'
+                     assert_select 'a[href=?]', "/issues/bulk_update?ids%5B%5D=1&issue%5Bcustom_field_values%5D%5B#{field.id}%5D=__none__", :text => 'none'
                    end
                  end
                end
                def test_context_menu_should_show_enabled_custom_fields_for_the_role_only
                  enabled_cf = IssueCustomField.generate!(:field_format => 'bool', :is_for_all => true, :tracker_ids => [1], :visible => false, :role_ids => [1,2])
                  disabled_cf = IssueCustomField.generate!(:field_format => 'bool', :is_for_all => true, :tracker_ids => [1], :visible => false, :role_ids => [2])
                  issue = Issue.generate!(:project_id => 1, :tracker_id => 1)
                  @request.session[:user_id] = 2
                  get :issues, :ids => [issue.id]
                  assert_select "li.cf_#{enabled_cf.id}"
                  assert_select "li.cf_#{disabled_cf.id}", 0
                end
                def test_context_menu_by_assignable_user_should_include_assigned_to_me_link
                  @request.session[:user_id] = 2
                  get :issues, :ids => [1]
                  assert_response :success
                  assert_template 'context_menus/issues'
-                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&amp;issue%5Bassigned_to_id%5D=2', :text => / me /
+                 assert_select 'a[href=?]', '/issues/bulk_update?ids%5B%5D=1&issue%5Bassigned_to_id%5D=2', :text => / me /
                end
                def test_context_menu_should_propose_shared_versions_for_issues_from_different_projects
                  @request.session[:user_id] = 2
                  version = Version.create!(:name => 'Shared', :sharing => 'system', :project_id => 1)
                  get :issues, :ids => [1, 4]
                  assert_response :success
                  assert_template 'context_menus/issues'
                  assert_include version, assigns(:versions)
                  assert_select 'a', :text => 'eCookbook - Shared'
                end
                def test_context_menu_with_issue_that_is_not_visible_should_fail
                  get :issues, :ids => [1, 4] # issue 4 is not visible
                  assert_response 302
                end
                def test_should_respond_with_404_without_ids
                  get :issues
                  assert_response 404
                end
                def test_time_entries_context_menu
                  @request.session[:user_id] = 2
                  get :time_entries, :ids => [1, 2]
                  assert_response :success
                  assert_template 'context_menus/time_entries'
                  assert_select 'a:not(.disabled)', :text => 'Edit'
                end
                def test_context_menu_for_one_time_entry
                  @request.session[:user_id] = 2
                  get :time_entries, :ids => [1]
                  assert_response :success
                  assert_template 'context_menus/time_entries'
                  assert_select 'a:not(.disabled)', :text => 'Edit'
                end
                def test_time_entries_context_menu_should_include_custom_fields
                  field = TimeEntryCustomField.generate!(:name => "Field", :field_format => "list", :possible_values => ["foo", "bar"])
                  @request.session[:user_id] = 2
                  get :time_entries, :ids => [1, 2]
                  assert_response :success
                  assert_select "li.cf_#{field.id}" do
-                   assert_select 'a[href=#]', :text => "Field"
+                   assert_select 'a[href="#"]', :text => "Field"
                    assert_select 'ul' do
                      assert_select 'a', 3
-                     assert_select 'a[href=?]', "/time_entries/bulk_update?ids%5B%5D=1&amp;ids%5B%5D=2&amp;time_entry%5Bcustom_field_values%5D%5B#{field.id}%5D=foo", :text => 'foo'
-                     assert_select 'a[href=?]', "/time_entries/bulk_update?ids%5B%5D=1&amp;ids%5B%5D=2&amp;time_entry%5Bcustom_field_values%5D%5B#{field.id}%5D=bar", :text => 'bar'
-                     assert_select 'a[href=?]', "/time_entries/bulk_update?ids%5B%5D=1&amp;ids%5B%5D=2&amp;time_entry%5Bcustom_field_values%5D%5B#{field.id}%5D=__none__", :text => 'none'
+                     assert_select 'a[href=?]', "/time_entries/bulk_update?ids%5B%5D=1&ids%5B%5D=2&time_entry%5Bcustom_field_values%5D%5B#{field.id}%5D=foo", :text => 'foo'
+                     assert_select 'a[href=?]', "/time_entries/bulk_update?ids%5B%5D=1&ids%5B%5D=2&time_entry%5Bcustom_field_values%5D%5B#{field.id}%5D=bar", :text => 'bar'
+                     assert_select 'a[href=?]', "/time_entries/bulk_update?ids%5B%5D=1&ids%5B%5D=2&time_entry%5Bcustom_field_values%5D%5B#{field.id}%5D=__none__", :text => 'none'
                    end
                  end
                end
                def test_time_entries_context_menu_without_edit_permission
                  @request.session[:user_id] = 2
                  Role.find_by_name('Manager').remove_permission! :edit_time_entries
                  get :time_entries, :ids => [1, 2]
                  assert_response :success
                  assert_template 'context_menus/time_entries'
                  assert_select 'a.disabled', :text => 'Edit'
                end
              end

test/functional/issues_controller_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/functional/issues_controller_transaction_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2015  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__)
              require 'issues_controller'
              class IssuesControllerTransactionTest < ActionController::TestCase
                tests IssuesController
                fixtures :projects,
                         :users,
                         :roles,
                         :members,
                         :member_roles,
                         :issues,
                         :issue_statuses,
                         :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
                self.use_transactional_fixtures = false
                def setup
                  User.current = nil
                end
                def test_update_stale_issue_should_not_update_the_issue
                  issue = Issue.find(2)
                  @request.session[:user_id] = 2
                  assert_no_difference 'Journal.count' do
                    assert_no_difference 'TimeEntry.count' do
                      put :update,
                            :id => issue.id,
                            :issue => {
                              :fixed_version_id => 4,
                              :notes => 'My notes',
                              :lock_version => (issue.lock_version - 1)
                            },
                            :time_entry => { :hours => '2.5', :comments => '', :activity_id => TimeEntryActivity.first.id }
                    end
                  end
                  assert_response :success
                  assert_template 'edit'
                  assert_select 'div.conflict'
                  assert_select 'input[name=?][value=?]', 'conflict_resolution', 'overwrite'
                  assert_select 'input[name=?][value=?]', 'conflict_resolution', 'add_notes'
                  assert_select 'label' do
                    assert_select 'input[name=?][value=?]', 'conflict_resolution', 'cancel'
                    assert_select 'a[href="/issues/2"]'
                  end
                end
                def test_update_stale_issue_should_save_attachments
                  set_tmp_attachments_directory
                  issue = Issue.find(2)
                  @request.session[:user_id] = 2
                  assert_no_difference 'Journal.count' do
                    assert_no_difference 'TimeEntry.count' do
                      assert_difference 'Attachment.count' do
                        put :update,
                              :id => issue.id,
                              :issue => {
                                :fixed_version_id => 4,
                                :notes => 'My notes',
                                :lock_version => (issue.lock_version - 1)
                              },
                              :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}},
                              :time_entry => { :hours => '2.5', :comments => '', :activity_id => TimeEntryActivity.first.id }
                      end
                    end
                  end
                  assert_response :success
                  assert_template 'edit'
                  attachment = Attachment.order('id DESC').first
                  assert_select 'input[name=?][value=?]', 'attachments[p0][token]', attachment.token
                  assert_select 'input[name=?][value=?]', 'attachments[p0][filename]', 'testfile.txt'
                end
                def test_update_stale_issue_without_notes_should_not_show_add_notes_option
                  issue = Issue.find(2)
                  @request.session[:user_id] = 2
                  put :update, :id => issue.id,
                        :issue => {
                          :fixed_version_id => 4,
                          :notes => '',
                          :lock_version => (issue.lock_version - 1)
                        }
                  assert_select 'div.conflict'
                  assert_select 'input[name=conflict_resolution][value=overwrite]'
                  assert_select 'input[name=conflict_resolution][value=add_notes]', 0
                  assert_select 'input[name=conflict_resolution][value=cancel]'
                end
                def test_update_stale_issue_should_show_conflicting_journals
                  @request.session[:user_id] = 2
                  put :update, :id => 1,
                        :issue => {
                          :fixed_version_id => 4,
                          :notes => '',
                          :lock_version => 2
                        },
                        :last_journal_id => 1
                  assert_not_nil assigns(:conflict_journals)
                  assert_equal 1, assigns(:conflict_journals).size
                  assert_equal 2, assigns(:conflict_journals).first.id
                  assert_select 'div.conflict', :text => /Some notes with Redmine links/
                end
                def test_update_stale_issue_without_previous_journal_should_show_all_journals
                  @request.session[:user_id] = 2
                  put :update, :id => 1,
                        :issue => {
                          :fixed_version_id => 4,
                          :notes => '',
                          :lock_version => 2
                        },
                        :last_journal_id => ''
                  assert_not_nil assigns(:conflict_journals)
                  assert_equal 2, assigns(:conflict_journals).size
                  assert_select 'div.conflict', :text => /Some notes with Redmine links/
                  assert_select 'div.conflict', :text => /Journal notes/
                end
                def test_update_stale_issue_should_show_private_journals_with_permission_only
                  journal = Journal.create!(:journalized => Issue.find(1), :notes => 'Privates notes', :private_notes => true, :user_id => 1)
                  @request.session[:user_id] = 2
                  put :update, :id => 1, :issue => {:fixed_version_id => 4, :lock_version => 2}, :last_journal_id => ''
                  assert_include journal, assigns(:conflict_journals)
                  Role.find(1).remove_permission! :view_private_notes
                  put :update, :id => 1, :issue => {:fixed_version_id => 4, :lock_version => 2}, :last_journal_id => ''
                  assert_not_include journal, assigns(:conflict_journals)
                end
                def test_update_stale_issue_with_overwrite_conflict_resolution_should_update
                  @request.session[:user_id] = 2
                  assert_difference 'Journal.count' do
                    put :update, :id => 1,
                          :issue => {
                            :fixed_version_id => 4,
                            :notes => 'overwrite_conflict_resolution',
                            :lock_version => 2
                          },
                          :conflict_resolution => 'overwrite'
                  end
                  assert_response 302
                  issue = Issue.find(1)
                  assert_equal 4, issue.fixed_version_id
                  journal = Journal.order('id DESC').first
                  assert_equal 'overwrite_conflict_resolution', journal.notes
                  assert journal.details.any?
                end
                def test_update_stale_issue_with_add_notes_conflict_resolution_should_update
                  @request.session[:user_id] = 2
                  assert_difference 'Journal.count' do
                    put :update, :id => 1,
                          :issue => {
                            :fixed_version_id => 4,
                            :notes => 'add_notes_conflict_resolution',
                            :lock_version => 2
                          },
                          :conflict_resolution => 'add_notes'
                  end
                  assert_response 302
                  issue = Issue.find(1)
                  assert_nil issue.fixed_version_id
                  journal = Journal.order('id DESC').first
                  assert_equal 'add_notes_conflict_resolution', journal.notes
                  assert journal.details.empty?
                end
                def test_update_stale_issue_with_cancel_conflict_resolution_should_redirect_without_updating
                  @request.session[:user_id] = 2
                  assert_no_difference 'Journal.count' do
                    put :update, :id => 1,
                          :issue => {
                            :fixed_version_id => 4,
                            :notes => 'add_notes_conflict_resolution',
                            :lock_version => 2
                          },
                          :conflict_resolution => 'cancel'
                  end
                  assert_redirected_to '/issues/1'
                  issue = Issue.find(1)
                  assert_nil issue.fixed_version_id
                end
                def test_put_update_with_spent_time_and_failure_should_not_add_spent_time
                  @request.session[:user_id] = 2
                  assert_no_difference('TimeEntry.count') do
                    put :update,
                         :id => 1,
                         :issue => { :subject => '' },
                         :time_entry => { :hours => '2.5', :comments => 'should not be added', :activity_id => TimeEntryActivity.first.id }
                    assert_response :success
                  end
                  assert_select 'input[name=?][value=?]', 'time_entry[hours]', '2.5'
                  assert_select 'input[name=?][value=?]', 'time_entry[comments]', 'should not be added'
                  assert_select 'select[name=?]', 'time_entry[activity_id]' do
-                   assert_select 'option[value=?][selected=selected]', TimeEntryActivity.first.id
+                   assert_select 'option[value=?][selected=selected]', TimeEntryActivity.first.id.to_s
                  end
                end
                def test_index_should_rescue_invalid_sql_query
                  IssueQuery.any_instance.stubs(:statement).returns("INVALID STATEMENT")
                  get :index
                  assert_response 500
                  assert_select 'p', :text => /An error occurred/
                  assert_nil session[:query]
                  assert_nil session[:issues_index_sort]
                end
              end

test/functional/issues_custom_fields_visibility_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 IssuesCustomFieldsVisibilityTest < ActionController::TestCase
                tests IssuesController
                fixtures :projects,
                         :users, :email_addresses,
                         :roles,
                         :members,
                         :member_roles,
                         :issue_statuses,
                         :trackers,
                         :projects_trackers,
                         :enabled_modules,
                         :enumerations,
                         :workflows
                def setup
                  CustomField.delete_all
                  Issue.delete_all
                  field_attributes = {:field_format => 'string', :is_for_all => true, :is_filter => true, :trackers => Tracker.all}
                  @fields = []
                  @fields << (@field1 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 1', :visible => true)))
                  @fields << (@field2 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 2', :visible => false, :role_ids => [1, 2])))
                  @fields << (@field3 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 3', :visible => false, :role_ids => [1, 3])))
                  @issue = Issue.generate!(
                    :author_id => 1,
                    :project_id => 1,
                    :tracker_id => 1,
                    :custom_field_values => {@field1.id => 'Value0', @field2.id => 'Value1', @field3.id => 'Value2'}
                  )
                  @user_with_role_on_other_project = User.generate!
                  User.add_to_project(@user_with_role_on_other_project, Project.find(2), Role.find(3))
                  @users_to_test = {
                    User.find(1) => [@field1, @field2, @field3],
                    User.find(3) => [@field1, @field2],
                    @user_with_role_on_other_project => [@field1], # should see field1 only on Project 1
                    User.generate! => [@field1],
                    User.anonymous => [@field1]
                  }
                  Member.where(:project_id => 1).each do |member|
                    member.destroy unless @users_to_test.keys.include?(member.principal)
                  end
                end
                def test_show_should_show_visible_custom_fields_only
                  @users_to_test.each do |user, fields|
                    @request.session[:user_id] = user.id
                    get :show, :id => @issue.id
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
                        assert_select 'td', {:text => "Value#{i}", :count => 1}, "User #{user.id} was not able to view #{field.name}"
                      else
                        assert_select 'td', {:text => "Value#{i}", :count => 0}, "User #{user.id} was able to view #{field.name}"
                      end
                    end
                  end
                end
                def test_show_should_show_visible_custom_fields_only_in_api
                  @users_to_test.each do |user, fields|
                    with_settings :rest_api_enabled => '1' do
                      get :show, :id => @issue.id, :format => 'xml', :include => 'custom_fields', :key => user.api_key
                    end
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
-                       assert_select "custom_field[id=#{field.id}] value", {:text => "Value#{i}", :count => 1}, "User #{user.id} was not able to view #{field.name} in API"
+                       assert_select "custom_field[id=?] value", field.id.to_s, {:text => "Value#{i}", :count => 1}, "User #{user.id} was not able to view #{field.name} in API"
                      else
-                       assert_select "custom_field[id=#{field.id}] value", {:text => "Value#{i}", :count => 0}, "User #{user.id} was not able to view #{field.name} in API"
+                       assert_select "custom_field[id=?] value", field.id.to_s, {:text => "Value#{i}", :count => 0}, "User #{user.id} was not able to view #{field.name} in API"
                      end
                    end
                  end
                end
                def test_show_should_show_visible_custom_fields_only_in_history
                  @issue.init_journal(User.find(1))
                  @issue.custom_field_values = {@field1.id => 'NewValue0', @field2.id => 'NewValue1', @field3.id => 'NewValue2'}
                  @issue.save!
                  @users_to_test.each do |user, fields|
                    @request.session[:user_id] = user.id
                    get :show, :id => @issue.id
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
                        assert_select 'ul.details i', {:text => "Value#{i}", :count => 1}, "User #{user.id} was not able to view #{field.name} change"
                      else
                        assert_select 'ul.details i', {:text => "Value#{i}", :count => 0}, "User #{user.id} was able to view #{field.name} change"
                      end
                    end
                  end
                end
                def test_show_should_show_visible_custom_fields_only_in_history_api
                  @issue.init_journal(User.find(1))
                  @issue.custom_field_values = {@field1.id => 'NewValue0', @field2.id => 'NewValue1', @field3.id => 'NewValue2'}
                  @issue.save!
                  @users_to_test.each do |user, fields|
                    with_settings :rest_api_enabled => '1' do
                      get :show, :id => @issue.id, :format => 'xml', :include => 'journals', :key => user.api_key
                    end
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
                        assert_select 'details old_value', {:text => "Value#{i}", :count => 1}, "User #{user.id} was not able to view #{field.name} change in API"
                      else
                        assert_select 'details old_value', {:text => "Value#{i}", :count => 0}, "User #{user.id} was able to view #{field.name} change in API"
                      end
                    end
                  end
                end
                def test_edit_should_show_visible_custom_fields_only
                  Role.anonymous.add_permission! :edit_issues
                  @users_to_test.each do |user, fields|
                    @request.session[:user_id] = user.id
                    get :edit, :id => @issue.id
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
                        assert_select 'input[value=?]', "Value#{i}", 1, "User #{user.id} was not able to edit #{field.name}"
                      else
                        assert_select 'input[value=?]', "Value#{i}", 0, "User #{user.id} was able to edit #{field.name}"
                      end
                    end
                  end
                end
                def test_update_should_update_visible_custom_fields_only
                  Role.anonymous.add_permission! :edit_issues
                  @users_to_test.each do |user, fields|
                    @request.session[:user_id] = user.id
                    put :update, :id => @issue.id,
                      :issue => {:custom_field_values => {
                        @field1.id.to_s => "User#{user.id}Value0",
                        @field2.id.to_s => "User#{user.id}Value1",
                        @field3.id.to_s => "User#{user.id}Value2",
                      }}
                    @issue.reload
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
                        assert_equal "User#{user.id}Value#{i}", @issue.custom_field_value(field), "User #{user.id} was not able to update #{field.name}"
                      else
                        assert_not_equal "User#{user.id}Value#{i}", @issue.custom_field_value(field), "User #{user.id} was able to update #{field.name}"
                      end
                    end
                  end
                end
                def test_index_should_show_visible_custom_fields_only
                  @users_to_test.each do |user, fields|
                    @request.session[:user_id] = user.id
                    get :index, :c => (["subject"] + @fields.map{|f| "cf_#{f.id}"})
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
                        assert_select 'td', {:text => "Value#{i}", :count => 1}, "User #{user.id} was not able to view #{field.name}"
                      else
                        assert_select 'td', {:text => "Value#{i}", :count => 0}, "User #{user.id} was able to view #{field.name}"
                      end
                    end
                  end
                end
                def test_index_as_csv_should_show_visible_custom_fields_only
                  @users_to_test.each do |user, fields|
                    @request.session[:user_id] = user.id
                    get :index, :c => (["subject"] + @fields.map{|f| "cf_#{f.id}"}), :format => 'csv'
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
                        assert_include "Value#{i}", response.body, "User #{user.id} was not able to view #{field.name} in CSV"
                      else
                        assert_not_include "Value#{i}", response.body, "User #{user.id} was able to view #{field.name} in CSV"
                      end
                    end
                  end
                end
                def test_index_with_partial_custom_field_visibility
                  Issue.delete_all
                  p1 = Project.generate!
                  p2 = Project.generate!
                  user = User.generate!
                  User.add_to_project(user, p1, Role.where(:id => [1, 3]).to_a)
                  User.add_to_project(user, p2, Role.where(:id => 3).to_a)
                  Issue.generate!(:project => p1, :tracker_id => 1, :custom_field_values => {@field2.id => 'ValueA'})
                  Issue.generate!(:project => p2, :tracker_id => 1, :custom_field_values => {@field2.id => 'ValueB'})
                  Issue.generate!(:project => p1, :tracker_id => 1, :custom_field_values => {@field2.id => 'ValueC'})
                  @request.session[:user_id] = user.id
                  get :index, :c => ["subject", "cf_#{@field2.id}"]
                  assert_select 'td', :text => 'ValueA'
                  assert_select 'td', :text => 'ValueB', :count => 0
                  assert_select 'td', :text => 'ValueC'
                  get :index, :sort => "cf_#{@field2.id}"
                  # ValueB is not visible to user and ignored while sorting
                  assert_equal %w(ValueB ValueA ValueC), assigns(:issues).map{|i| i.custom_field_value(@field2)}
                  get :index, :set_filter => '1', "cf_#{@field2.id}" => '*'
                  assert_equal %w(ValueA ValueC), assigns(:issues).map{|i| i.custom_field_value(@field2)}
                  CustomField.update_all(:field_format => 'list')
                  get :index, :group => "cf_#{@field2.id}"
                  assert_equal %w(ValueA ValueC), assigns(:issues).map{|i| i.custom_field_value(@field2)}
                end
                def test_create_should_send_notifications_according_custom_fields_visibility
                  # anonymous user is never notified
                  users_to_test = @users_to_test.reject {|k,v| k.anonymous?}
                  ActionMailer::Base.deliveries.clear
                  @request.session[:user_id] = 1
                  with_settings :bcc_recipients => '1' do
                    assert_difference 'Issue.count' do
                      post :create,
                        :project_id => 1,
                        :issue => {
                          :tracker_id => 1,
                          :status_id => 1,
                          :subject => 'New issue',
                          :priority_id => 5,
                          :custom_field_values => {@field1.id.to_s => 'Value0', @field2.id.to_s => 'Value1', @field3.id.to_s => 'Value2'},
                          :watcher_user_ids => users_to_test.keys.map(&:id)
                        }
                      assert_response 302
                    end
                  end
                  assert_equal users_to_test.values.uniq.size, ActionMailer::Base.deliveries.size
                  # tests that each user receives 1 email with the custom fields he is allowed to see only
                  users_to_test.each do |user, fields|
                    mails = ActionMailer::Base.deliveries.select {|m| m.bcc.include? user.mail}
                    assert_equal 1, mails.size
                    mail = mails.first
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
                        assert_mail_body_match "Value#{i}", mail, "User #{user.id} was not able to view #{field.name} in notification"
                      else
                        assert_mail_body_no_match "Value#{i}", mail, "User #{user.id} was able to view #{field.name} in notification"
                      end
                    end
                  end
                end
                def test_update_should_send_notifications_according_custom_fields_visibility
                  # anonymous user is never notified
                  users_to_test = @users_to_test.reject {|k,v| k.anonymous?}
                  users_to_test.keys.each do |user|
                    Watcher.create!(:user => user, :watchable => @issue)
                  end
                  ActionMailer::Base.deliveries.clear
                  @request.session[:user_id] = 1
                  with_settings :bcc_recipients => '1' do
                    put :update,
                      :id => @issue.id,
                      :issue => {
                        :custom_field_values => {@field1.id.to_s => 'NewValue0', @field2.id.to_s => 'NewValue1', @field3.id.to_s => 'NewValue2'}
                      }
                    assert_response 302
                  end
                  assert_equal users_to_test.values.uniq.size, ActionMailer::Base.deliveries.size
                  # tests that each user receives 1 email with the custom fields he is allowed to see only
                  users_to_test.each do |user, fields|
                    mails = ActionMailer::Base.deliveries.select {|m| m.bcc.include? user.mail}
                    assert_equal 1, mails.size
                    mail = mails.first
                    @fields.each_with_index do |field, i|
                      if fields.include?(field)
                        assert_mail_body_match "Value#{i}", mail, "User #{user.id} was not able to view #{field.name} in notification"
                      else
                        assert_mail_body_no_match "Value#{i}", mail, "User #{user.id} was able to view #{field.name} in notification"
                      end
                    end
                  end
                end
                def test_updating_hidden_custom_fields_only_should_not_notifiy_user
                  # anonymous user is never notified
                  users_to_test = @users_to_test.reject {|k,v| k.anonymous?}
                  users_to_test.keys.each do |user|
                    Watcher.create!(:user => user, :watchable => @issue)
                  end
                  ActionMailer::Base.deliveries.clear
                  @request.session[:user_id] = 1
                  with_settings :bcc_recipients => '1' do
                    put :update,
                      :id => @issue.id,
                      :issue => {
                        :custom_field_values => {@field2.id.to_s => 'NewValue1', @field3.id.to_s => 'NewValue2'}
                      }
                    assert_response 302
                  end
                  users_to_test.each do |user, fields|
                    mails = ActionMailer::Base.deliveries.select {|m| m.bcc.include? user.mail}
                    if (fields & [@field2, @field3]).any?
                      assert_equal 1, mails.size, "User #{user.id} was not notified"
                    else
                      assert_equal 0, mails.size, "User #{user.id} was notified"
                    end
                  end
                end
              end

test/functional/my_controller_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 MyControllerTest < ActionController::TestCase
                fixtures :users, :email_addresses, :user_preferences, :roles, :projects, :members, :member_roles,
                :issues, :issue_statuses, :trackers, :enumerations, :custom_fields, :auth_sources
                def setup
                  @request.session[:user_id] = 2
                end
                def test_index
                  get :index
                  assert_response :success
                  assert_template 'page'
                end
                def test_page
                  get :page
                  assert_response :success
                  assert_template 'page'
                end
                def test_page_with_timelog_block
                  preferences = User.find(2).pref
                  preferences[:my_page_layout] = {'top' => ['timelog']}
                  preferences.save!
                  TimeEntry.create!(:user => User.find(2), :spent_on => Date.yesterday, :issue_id => 1, :hours => 2.5, :activity_id => 10)
                  get :page
                  assert_response :success
                  assert_select 'tr.time-entry' do
                    assert_select 'td.subject a[href="/issues/1"]'
                    assert_select 'td.hours', :text => '2.50'
                  end
                end
                def test_page_with_all_blocks
                  blocks = MyController::BLOCKS.keys
                  preferences = User.find(2).pref
                  preferences[:my_page_layout] = {'top' => blocks}
                  preferences.save!
                  get :page
                  assert_response :success
                  assert_select 'div.mypage-box', blocks.size
                end
                def test_my_account_should_show_editable_custom_fields
                  get :account
                  assert_response :success
                  assert_template 'account'
                  assert_equal User.find(2), assigns(:user)
                  assert_select 'input[name=?]', 'user[custom_field_values][4]'
                end
                def test_my_account_should_not_show_non_editable_custom_fields
                  UserCustomField.find(4).update_attribute :editable, false
                  get :account
                  assert_response :success
                  assert_template 'account'
                  assert_equal User.find(2), assigns(:user)
                  assert_select 'input[name=?]', 'user[custom_field_values][4]', 0
                end
                def test_my_account_should_show_language_select
                  get :account
                  assert_response :success
                  assert_select 'select[name=?]', 'user[language]'
                end
                def test_my_account_should_not_show_language_select_with_force_default_language_for_loggedin
                  with_settings :force_default_language_for_loggedin => '1' do
                    get :account
                    assert_response :success
                    assert_select 'select[name=?]', 'user[language]', 0
                  end
                end
                def test_update_account
                  post :account,
                    :user => {
                      :firstname => "Joe",
                      :login => "root",
                      :admin => 1,
                      :group_ids => ['10'],
                      :custom_field_values => {"4" => "0100562500"}
                    }
                  assert_redirected_to '/my/account'
                  user = User.find(2)
                  assert_equal user, assigns(:user)
                  assert_equal "Joe", user.firstname
                  assert_equal "jsmith", user.login
                  assert_equal "0100562500", user.custom_value_for(4).value
                  # ignored
                  assert !user.admin?
                  assert user.groups.empty?
                end
                def test_my_account_should_show_destroy_link
                  get :account
                  assert_select 'a[href="/my/account/destroy"]'
                end
                def test_get_destroy_should_display_the_destroy_confirmation
                  get :destroy
                  assert_response :success
                  assert_template 'destroy'
-                 assert_select 'form[action=/my/account/destroy]' do
+                 assert_select 'form[action="/my/account/destroy"]' do
                    assert_select 'input[name=confirm]'
                  end
                end
                def test_post_destroy_without_confirmation_should_not_destroy_account
                  assert_no_difference 'User.count' do
                    post :destroy
                  end
                  assert_response :success
                  assert_template 'destroy'
                end
                def test_post_destroy_without_confirmation_should_destroy_account
                  assert_difference 'User.count', -1 do
                    post :destroy, :confirm => '1'
                  end
                  assert_redirected_to '/'
                  assert_match /deleted/i, flash[:notice]
                end
                def test_post_destroy_with_unsubscribe_not_allowed_should_not_destroy_account
                  User.any_instance.stubs(:own_account_deletable?).returns(false)
                  assert_no_difference 'User.count' do
                    post :destroy, :confirm => '1'
                  end
                  assert_redirected_to '/my/account'
                end
                def test_change_password
                  get :password
                  assert_response :success
                  assert_template 'password'
                  # non matching password confirmation
                  post :password, :password => 'jsmith',
                                  :new_password => 'secret123',
                                  :new_password_confirmation => 'secret1234'
                  assert_response :success
                  assert_template 'password'
                  assert_select_error /Password doesn.*t match confirmation/
                  # wrong password
                  post :password, :password => 'wrongpassword',
                                  :new_password => 'secret123',
                                  :new_password_confirmation => 'secret123'
                  assert_response :success
                  assert_template 'password'
                  assert_equal 'Wrong password', flash[:error]
                  # good password
                  post :password, :password => 'jsmith',
                                  :new_password => 'secret123',
                                  :new_password_confirmation => 'secret123'
                  assert_redirected_to '/my/account'
                  assert User.try_to_login('jsmith', 'secret123')
                end
                def test_change_password_kills_other_sessions
                  @request.session[:ctime] = (Time.now - 30.minutes).utc.to_i
                  jsmith = User.find(2)
                  jsmith.passwd_changed_on = Time.now
                  jsmith.save!
                  get 'account'
                  assert_response 302
                  assert flash[:error].match(/Your session has expired/)
                end
                def test_change_password_should_redirect_if_user_cannot_change_its_password
                  User.find(2).update_attribute(:auth_source_id, 1)
                  get :password
                  assert_not_nil flash[:error]
                  assert_redirected_to '/my/account'
                end
                def test_page_layout
                  get :page_layout
                  assert_response :success
                  assert_template 'page_layout'
                end
                def test_add_block
                  post :add_block, :block => 'issuesreportedbyme'
                  assert_redirected_to '/my/page_layout'
                  assert User.find(2).pref[:my_page_layout]['top'].include?('issuesreportedbyme')
                end
                def test_add_invalid_block_should_redirect
                  post :add_block, :block => 'invalid'
                  assert_redirected_to '/my/page_layout'
                end
                def test_remove_block
                  post :remove_block, :block => 'issuesassignedtome'
                  assert_redirected_to '/my/page_layout'
                  assert !User.find(2).pref[:my_page_layout].values.flatten.include?('issuesassignedtome')
                end
                def test_order_blocks
                  xhr :post, :order_blocks, :group => 'left', 'blocks' => ['documents', 'calendar', 'latestnews']
                  assert_response :success
                  assert_equal ['documents', 'calendar', 'latestnews'], User.find(2).pref[:my_page_layout]['left']
                end
                def test_reset_rss_key_with_existing_key
                  @previous_token_value = User.find(2).rss_key # Will generate one if it's missing
                  post :reset_rss_key
                  assert_not_equal @previous_token_value, User.find(2).rss_key
                  assert User.find(2).rss_token
                  assert_match /reset/, flash[:notice]
                  assert_redirected_to '/my/account'
                end
                def test_reset_rss_key_without_existing_key
                  assert_nil User.find(2).rss_token
                  post :reset_rss_key
                  assert User.find(2).rss_token
                  assert_match /reset/, flash[:notice]
                  assert_redirected_to '/my/account'
                end
                def test_reset_api_key_with_existing_key
                  @previous_token_value = User.find(2).api_key # Will generate one if it's missing
                  post :reset_api_key
                  assert_not_equal @previous_token_value, User.find(2).api_key
                  assert User.find(2).api_token
                  assert_match /reset/, flash[:notice]
                  assert_redirected_to '/my/account'
                end
                def test_reset_api_key_without_existing_key
                  assert_nil User.find(2).api_token
                  post :reset_api_key
                  assert User.find(2).api_token
                  assert_match /reset/, flash[:notice]
                  assert_redirected_to '/my/account'
                end
              end

test/functional/repositories_bazaar_controller_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 RepositoriesBazaarControllerTest < ActionController::TestCase
                tests RepositoriesController
                fixtures :projects, :users, :email_addresses, :roles, :members, :member_roles,
                         :repositories, :enabled_modules
                REPOSITORY_PATH = Rails.root.join('tmp/test/bazaar_repository').to_s
                REPOSITORY_PATH_TRUNK = File.join(REPOSITORY_PATH, "trunk")
                PRJ_ID = 3
                CHAR_1_UTF8_HEX   = "\xc3\x9c".dup.force_encoding('UTF-8')
                def setup
                  User.current = nil
                  @project = Project.find(PRJ_ID)
                  @repository = Repository::Bazaar.create(
                                  :project      => @project,
                                  :url          => REPOSITORY_PATH_TRUNK,
                                  :log_encoding => 'UTF-8')
                  assert @repository
                end
                if File.directory?(REPOSITORY_PATH)
                  def test_get_new
                    @request.session[:user_id] = 1
                    @project.repository.destroy
                    get :new, :project_id => 'subproject1', :repository_scm => 'Bazaar'
                    assert_response :success
                    assert_template 'new'
                    assert_kind_of Repository::Bazaar, assigns(:repository)
                    assert assigns(:repository).new_record?
                  end
                  def test_browse_root
                    get :show, :id => PRJ_ID
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal 2, assigns(:entries).size
                    assert assigns(:entries).detect {|e| e.name == 'directory' && e.kind == 'dir'}
                    assert assigns(:entries).detect {|e| e.name == 'doc-mkdir.txt' && e.kind == 'file'}
                  end
                  def test_browse_directory
                    get :show, :id => PRJ_ID, :path => repository_path_hash(['directory'])[:param]
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal ['doc-ls.txt', 'document.txt', 'edit.png'], assigns(:entries).collect(&:name)
                    entry = assigns(:entries).detect {|e| e.name == 'edit.png'}
                    assert_not_nil entry
                    assert_equal 'file', entry.kind
                    assert_equal 'directory/edit.png', entry.path
                  end
                  def test_browse_at_given_revision
                    get :show, :id => PRJ_ID, :path => repository_path_hash([])[:param],
                        :rev => 3
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal ['directory', 'doc-deleted.txt', 'doc-ls.txt', 'doc-mkdir.txt'],
                                 assigns(:entries).collect(&:name)
                  end
                  def test_changes
                    get :changes, :id => PRJ_ID,
                        :path => repository_path_hash(['doc-mkdir.txt'])[:param]
                    assert_response :success
                    assert_template 'changes'
                    assert_select 'h2', :text => /doc-mkdir.txt/
                  end
                  def test_entry_show
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['directory', 'doc-ls.txt'])[:param]
                    assert_response :success
                    assert_template 'entry'
                    # Line 19
                    assert_select 'tr#L29 td.line-code', :text => /Show help message/
                  end
                  def test_entry_download
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['directory', 'doc-ls.txt'])[:param],
                        :format => 'raw'
                    assert_response :success
                    # File content
                    assert @response.body.include?('Show help message')
                  end
                  def test_directory_entry
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['directory'])[:param]
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entry)
                    assert_equal 'directory', assigns(:entry).name
                  end
                  def test_diff
                    # Full diff of changeset 3
                    ['inline', 'sbs'].each do |dt|
                      get :diff, :id => PRJ_ID, :rev => 3, :type => dt
                      assert_response :success
                      assert_template 'diff'
                      # Line 11 removed
-                     assert_select 'th.line-num:content(11) ~ td.diff_out', :text => /Display more information/
+                     assert_select 'th.line-num:contains(11) ~ td.diff_out', :text => /Display more information/
                    end
                  end
                  def test_annotate
                    get :annotate, :id => PRJ_ID,
                        :path => repository_path_hash(['doc-mkdir.txt'])[:param]
                    assert_response :success
                    assert_template 'annotate'
                    assert_select "th.line-num", :text => '2' do
                      assert_select "+ td.revision" do
                        assert_select "a", :text => '3'
                        assert_select "+ td.author", :text => "jsmith@" do
                          assert_select "+ td",
                                        :text => "Main purpose:"
                        end
                      end
                    end
                  end
                  def test_annotate_author_escaping
                    repository = Repository::Bazaar.create(
                                  :project      => @project,
                                  :url          => File.join(REPOSITORY_PATH, "author_escaping"),
                                  :identifier => 'author_escaping',
                                  :log_encoding => 'UTF-8')
                    assert repository
                    get :annotate, :id => PRJ_ID, :repository_id => 'author_escaping',
                        :path => repository_path_hash(['author-escaping-test.txt'])[:param]
                    assert_response :success
                    assert_template 'annotate'
                    assert_select "th.line-num", :text => '1' do
                      assert_select "+ td.revision" do
                        assert_select "a", :text => '2'
-                       assert_select "+ td.author", :text => "test &amp;" do
+                       assert_select "+ td.author", :text => "test &" do
                          assert_select "+ td",
                                        :text => "author escaping test"
                        end
                      end
                    end
                  end
                  def test_annotate_author_non_ascii
                    log_encoding = nil
                    if Encoding.locale_charmap == "UTF-8" ||
                         Encoding.locale_charmap == "ISO-8859-1"
                      log_encoding = Encoding.locale_charmap
                    end
                    unless log_encoding.nil?
                      repository = Repository::Bazaar.create(
                                    :project      => @project,
                                    :url          => File.join(REPOSITORY_PATH, "author_non_ascii"),
                                    :identifier => 'author_non_ascii',
                                    :log_encoding => log_encoding)
                      assert repository
                      get :annotate, :id => PRJ_ID, :repository_id => 'author_non_ascii',
                          :path => repository_path_hash(['author-non-ascii-test.txt'])[:param]
                      assert_response :success
                      assert_template 'annotate'
                      assert_select "th.line-num", :text => '1' do
                        assert_select "+ td.revision" do
                          assert_select "a", :text => '2'
                          assert_select "+ td.author", :text => "test #{CHAR_1_UTF8_HEX}" do
                            assert_select "+ td",
                                          :text => "author non ASCII test"
                          end
                        end
                      end
                    end
                  end
                  def test_destroy_valid_repository
                    @request.session[:user_id] = 1 # admin
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    assert @repository.changesets.count > 0
                    assert_difference 'Repository.count', -1 do
                      delete :destroy, :id => @repository.id
                    end
                    assert_response 302
                    @project.reload
                    assert_nil @project.repository
                  end
                  def test_destroy_invalid_repository
                    @request.session[:user_id] = 1 # admin
                    @project.repository.destroy
                    @repository = Repository::Bazaar.create!(
                                  :project      => @project,
                                  :url          => "/invalid",
                                  :log_encoding => 'UTF-8')
                    @repository.fetch_changesets
                    @repository.reload
                    assert_equal 0, @repository.changesets.count
                    assert_difference 'Repository.count', -1 do
                      delete :destroy, :id => @repository.id
                    end
                    assert_response 302
                    @project.reload
                    assert_nil @project.repository
                  end
                else
                  puts "Bazaar test repository NOT FOUND. Skipping functional tests !!!"
                  def test_fake; assert true end
                end
              end

test/functional/repositories_controller_test.rb +2 -8

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 RepositoriesControllerTest < ActionController::TestCase
                fixtures :projects, :users, :email_addresses, :roles, :members, :member_roles, :enabled_modules,
                         :repositories, :issues, :issue_statuses, :changesets, :changes,
                         :issue_categories, :enumerations, :custom_fields, :custom_values, :trackers
                def setup
                  User.current = nil
                end
                def test_new
                  @request.session[:user_id] = 1
                  get :new, :project_id => 'subproject1'
                  assert_response :success
                  assert_template 'new'
                  assert_kind_of Repository::Subversion, assigns(:repository)
                  assert assigns(:repository).new_record?
                  assert_select 'input[name=?]:not([disabled])', 'repository[url]'
                end
                def test_new_should_propose_enabled_scm_only
                  @request.session[:user_id] = 1
                  with_settings :enabled_scm => ['Mercurial', 'Git'] do
                    get :new, :project_id => 'subproject1'
                  end
                  assert_response :success
                  assert_template 'new'
                  assert_kind_of Repository::Mercurial, assigns(:repository)
                  assert_select 'select[name=repository_scm]' do
                    assert_select 'option', 3
                    assert_select 'option[value=Mercurial][selected=selected]'
                    assert_select 'option[value=Git]:not([selected])'
                  end
                end
                def test_create
                  @request.session[:user_id] = 1
                  assert_difference 'Repository.count' do
                    post :create, :project_id => 'subproject1',
                         :repository_scm => 'Subversion',
                         :repository => {:url => 'file:///test', :is_default => '1', :identifier => ''}
                  end
                  assert_response 302
                  repository = Repository.order('id DESC').first
                  assert_kind_of Repository::Subversion, repository
                  assert_equal 'file:///test', repository.url
                end
                def test_create_with_failure
                  @request.session[:user_id] = 1
                  assert_no_difference 'Repository.count' do
                    post :create, :project_id => 'subproject1',
                         :repository_scm => 'Subversion',
                         :repository => {:url => 'invalid'}
                  end
                  assert_response :success
                  assert_template 'new'
                  assert_kind_of Repository::Subversion, assigns(:repository)
                  assert assigns(:repository).new_record?
                end
                def test_edit
                  @request.session[:user_id] = 1
                  get :edit, :id => 11
                  assert_response :success
                  assert_template 'edit'
                  assert_equal Repository.find(11), assigns(:repository)
                  assert_select 'input[name=?][value=?][disabled=disabled]', 'repository[url]', 'svn://localhost/test'
                end
                def test_update
                  @request.session[:user_id] = 1
                  put :update, :id => 11, :repository => {:password => 'test_update'}
                  assert_response 302
                  assert_equal 'test_update', Repository.find(11).password
                end
                def test_update_with_failure
                  @request.session[:user_id] = 1
                  put :update, :id => 11, :repository => {:password => 'x'*260}
                  assert_response :success
                  assert_template 'edit'
                  assert_equal Repository.find(11), assigns(:repository)
                end
                def test_destroy
                  @request.session[:user_id] = 1
                  assert_difference 'Repository.count', -1 do
                    delete :destroy, :id => 11
                  end
                  assert_response 302
                  assert_nil Repository.find_by_id(11)
                end
                def test_show_with_autofetch_changesets_enabled_should_fetch_changesets
                  Repository::Subversion.any_instance.expects(:fetch_changesets).once
                  with_settings :autofetch_changesets => '1' do
                    get :show, :id => 1
                  end
                end
                def test_show_with_autofetch_changesets_disabled_should_not_fetch_changesets
                  Repository::Subversion.any_instance.expects(:fetch_changesets).never
                  with_settings :autofetch_changesets => '0' do
                    get :show, :id => 1
                  end
                end
                def test_show_with_closed_project_should_not_fetch_changesets
                  Repository::Subversion.any_instance.expects(:fetch_changesets).never
                  Project.find(1).close
                  with_settings :autofetch_changesets => '1' do
                    get :show, :id => 1
                  end
                end
                def test_revisions
                  get :revisions, :id => 1
                  assert_response :success
                  assert_template 'revisions'
                  assert_equal Repository.find(10), assigns(:repository)
                  assert_not_nil assigns(:changesets)
                end
                def test_revisions_for_other_repository
                  repository = Repository::Subversion.create!(:project_id => 1, :identifier => 'foo', :url => 'file:///foo')
                  get :revisions, :id => 1, :repository_id => 'foo'
                  assert_response :success
                  assert_template 'revisions'
                  assert_equal repository, assigns(:repository)
                  assert_not_nil assigns(:changesets)
                end
                def test_revisions_for_invalid_repository
                  get :revisions, :id => 1, :repository_id => 'foo'
                  assert_response 404
                end
                def test_revision
                  get :revision, :id => 1, :rev => 1
                  assert_response :success
                  assert_not_nil assigns(:changeset)
                  assert_equal "1", assigns(:changeset).revision
                end
                def test_revision_should_show_add_related_issue_form
                  Role.find(1).add_permission! :manage_related_issues
                  @request.session[:user_id] = 2
                  get :revision, :id => 1, :rev => 1
                  assert_response :success
                  assert_select 'form[action=?]', '/projects/ecookbook/repository/revisions/1/issues' do
                    assert_select 'input[name=?]', 'issue_id'
                  end
                end
                def test_revision_should_not_change_the_project_menu_link
                  get :revision, :id => 1, :rev => 1
                  assert_response :success
                  assert_select '#main-menu a.repository[href=?]', '/projects/ecookbook/repository'
                end
                def test_revision_with_before_nil_and_afer_normal
                  get :revision, {:id => 1, :rev => 1}
                  assert_response :success
                  assert_template 'revision'
                  assert_select 'div.contextual' do
                    assert_select 'a[href=?]', '/projects/ecookbook/repository/revisions/0', 0
                    assert_select 'a[href=?]', '/projects/ecookbook/repository/revisions/2'
                  end
                end
                def test_add_related_issue
                  @request.session[:user_id] = 2
                  assert_difference 'Changeset.find(103).issues.size' do
                    xhr :post, :add_related_issue, :id => 1, :rev => 4, :issue_id => 2, :format => 'js'
                    assert_response :success
                    assert_template 'add_related_issue'
                    assert_equal 'text/javascript', response.content_type
                  end
                  assert_equal [2], Changeset.find(103).issue_ids
                  assert_include 'related-issues', response.body
                  assert_include 'Feature request #2', response.body
                end
                def test_add_related_issue_should_accept_issue_id_with_sharp
                  @request.session[:user_id] = 2
                  assert_difference 'Changeset.find(103).issues.size' do
                    xhr :post, :add_related_issue, :id => 1, :rev => 4, :issue_id => "#2", :format => 'js'
                  end
                  assert_equal [2], Changeset.find(103).issue_ids
                end
                def test_add_related_issue_with_invalid_issue_id
                  @request.session[:user_id] = 2
                  assert_no_difference 'Changeset.find(103).issues.size' do
                    xhr :post, :add_related_issue, :id => 1, :rev => 4, :issue_id => 9999, :format => 'js'
                    assert_response :success
                    assert_template 'add_related_issue'
                    assert_equal 'text/javascript', response.content_type
                  end
                  assert_include 'alert("Issue is invalid")', response.body
                end
                def test_remove_related_issue
                  Changeset.find(103).issues << Issue.find(1)
                  Changeset.find(103).issues << Issue.find(2)
                  @request.session[:user_id] = 2
                  assert_difference 'Changeset.find(103).issues.size', -1 do
                    xhr :delete, :remove_related_issue, :id => 1, :rev => 4, :issue_id => 2, :format => 'js'
                    assert_response :success
                    assert_template 'remove_related_issue'
                    assert_equal 'text/javascript', response.content_type
                  end
                  assert_equal [1], Changeset.find(103).issue_ids
                  assert_include 'related-issue-2', response.body
                end
                def test_graph_commits_per_month
                  # Make sure there's some data to display
                  latest = Project.find(1).repository.changesets.maximum(:commit_date)
                  assert_not_nil latest
                  Date.stubs(:today).returns(latest.to_date + 10)
                  get :graph, :id => 1, :graph => 'commits_per_month'
                  assert_response :success
                  assert_equal 'image/svg+xml', @response.content_type
                end
                def test_graph_commits_per_author
                  get :graph, :id => 1, :graph => 'commits_per_author'
                  assert_response :success
                  assert_equal 'image/svg+xml', @response.content_type
                end
                def test_get_committers
                  @request.session[:user_id] = 2
                  # add a commit with an unknown user
                  Changeset.create!(
                      :repository => Project.find(1).repository,
                      :committer  => 'foo',
                      :committed_on => Time.now,
                      :revision => 100,
                      :comments => 'Committed by foo.'
                   )
                  get :committers, :id => 10
                  assert_response :success
                  assert_template 'committers'
-                 assert_select 'td:content(dlopper) + td select' do
-                   assert_select 'option[value="3"][selected=selected]', :text => 'Dave Lopper'
-                 end
-                 assert_select 'td:content(foo) + td select' do
-                   assert_select 'option[value=""]'
-                   assert_select 'option[selected=selected]', 0 # no option selected
-                 end
+                 assert_select 'input[value=dlopper] + select option[value="3"][selected=selected]', :text => 'Dave Lopper'
+                 assert_select 'input[value=foo] + select option[selected=selected]', 0 # no option selected
                end
                def test_post_committers
                  @request.session[:user_id] = 2
                  # add a commit with an unknown user
                  c = Changeset.create!(
                          :repository => Project.find(1).repository,
                          :committer  => 'foo',
                          :committed_on => Time.now,
                          :revision => 100,
                          :comments => 'Committed by foo.'
                        )
                  assert_no_difference "Changeset.where(:user_id => 3).count" do
                    post :committers, :id => 10, :committers => { '0' => ['foo', '2'], '1' => ['dlopper', '3']}
                    assert_response 302
                    assert_equal User.find(2), c.reload.user
                  end
                end
              end

test/functional/repositories_darcs_controller_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 RepositoriesDarcsControllerTest < ActionController::TestCase
                tests RepositoriesController
                fixtures :projects, :users, :email_addresses, :roles, :members, :member_roles,
                         :repositories, :enabled_modules
                REPOSITORY_PATH = Rails.root.join('tmp/test/darcs_repository').to_s
                PRJ_ID = 3
                NUM_REV = 6
                def setup
                  User.current = nil
                  @project = Project.find(PRJ_ID)
                  @repository = Repository::Darcs.create(
                                      :project      => @project,
                                      :url          => REPOSITORY_PATH,
                                      :log_encoding => 'UTF-8'
                                      )
                  assert @repository
                end
                if File.directory?(REPOSITORY_PATH)
                  def test_get_new
                    @request.session[:user_id] = 1
                    @project.repository.destroy
                    get :new, :project_id => 'subproject1', :repository_scm => 'Darcs'
                    assert_response :success
                    assert_template 'new'
                    assert_kind_of Repository::Darcs, assigns(:repository)
                    assert assigns(:repository).new_record?
                  end
                  def test_browse_root
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal 3, assigns(:entries).size
                    assert assigns(:entries).detect {|e| e.name == 'images' && e.kind == 'dir'}
                    assert assigns(:entries).detect {|e| e.name == 'sources' && e.kind == 'dir'}
                    assert assigns(:entries).detect {|e| e.name == 'README' && e.kind == 'file'}
                  end
                  def test_browse_directory
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID, :path => repository_path_hash(['images'])[:param]
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal ['delete.png', 'edit.png'], assigns(:entries).collect(&:name)
                    entry = assigns(:entries).detect {|e| e.name == 'edit.png'}
                    assert_not_nil entry
                    assert_equal 'file', entry.kind
                    assert_equal 'images/edit.png', entry.path
                  end
                  def test_browse_at_given_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID, :path => repository_path_hash(['images'])[:param],
                        :rev => 1
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal ['delete.png'], assigns(:entries).collect(&:name)
                  end
                  def test_changes
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :changes, :id => PRJ_ID,
                        :path => repository_path_hash(['images', 'edit.png'])[:param]
                    assert_response :success
                    assert_template 'changes'
                    assert_select 'h2', :text => /edit.png/
                  end
                  def test_diff
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    # Full diff of changeset 5
                    ['inline', 'sbs'].each do |dt|
                      get :diff, :id => PRJ_ID, :rev => 5, :type => dt
                      assert_response :success
                      assert_template 'diff'
                      # Line 22 removed
-                     assert_select 'th.line-num:content(22) ~ td.diff_out', :text => /def remove/
+                     assert_select 'th.line-num:contains(22) ~ td.diff_out', :text => /def remove/
                    end
                  end
                  def test_destroy_valid_repository
                    @request.session[:user_id] = 1 # admin
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_difference 'Repository.count', -1 do
                      delete :destroy, :id => @repository.id
                    end
                    assert_response 302
                    @project.reload
                    assert_nil @project.repository
                  end
                  def test_destroy_invalid_repository
                    @request.session[:user_id] = 1 # admin
                    @project.repository.destroy
                    @repository = Repository::Darcs.create!(
                                      :project      => @project,
                                      :url          => "/invalid",
                                      :log_encoding => 'UTF-8'
                                      )
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal 0, @repository.changesets.count
                    assert_difference 'Repository.count', -1 do
                      delete :destroy, :id => @repository.id
                    end
                    assert_response 302
                    @project.reload
                    assert_nil @project.repository
                  end
                else
                  puts "Darcs test repository NOT FOUND. Skipping functional tests !!!"
                  def test_fake; assert true end
                end
              end

test/functional/repositories_git_controller_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 RepositoriesGitControllerTest < ActionController::TestCase
                tests RepositoriesController
                fixtures :projects, :users, :email_addresses, :roles, :members, :member_roles,
                         :repositories, :enabled_modules
                REPOSITORY_PATH = Rails.root.join('tmp/test/git_repository').to_s
                REPOSITORY_PATH.gsub!(/\//, "\\") if Redmine::Platform.mswin?
                PRJ_ID     = 3
                CHAR_1_HEX = "\xc3\x9c".force_encoding('UTF-8')
                FELIX_HEX  = "Felix Sch\xC3\xA4fer".force_encoding('UTF-8')
                NUM_REV = 28
                ## 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
                  @ruby19_non_utf8_pass = Encoding.default_external.to_s != 'UTF-8'
                  User.current = nil
                  @project    = Project.find(PRJ_ID)
                  @repository = Repository::Git.create(
                                    :project       => @project,
                                    :url           => REPOSITORY_PATH,
                                    :path_encoding => 'ISO-8859-1'
                                    )
                  assert @repository
                end
                def test_create_and_update
                  @request.session[:user_id] = 1
                  assert_difference 'Repository.count' do
                    post :create, :project_id => 'subproject1',
                                  :repository_scm => 'Git',
                                  :repository => {
                                     :url => '/test',
                                     :is_default => '0',
                                     :identifier => 'test-create',
                                     :extra_report_last_commit => '1',
                                   }
                  end
                  assert_response 302
                  repository = Repository.order('id DESC').first
                  assert_kind_of Repository::Git, repository
                  assert_equal '/test', repository.url
                  assert_equal true, repository.extra_report_last_commit
                  put :update, :id => repository.id,
                               :repository => {
                                   :extra_report_last_commit => '0'
                               }
                  assert_response 302
                  repo2 = Repository.find(repository.id)
                  assert_equal false, repo2.extra_report_last_commit
                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_get_new
                    @request.session[:user_id] = 1
                    @project.repository.destroy
                    get :new, :project_id => 'subproject1', :repository_scm => 'Git'
                    assert_response :success
                    assert_template 'new'
                    assert_kind_of Repository::Git, assigns(:repository)
                    assert assigns(:repository).new_record?
                  end
                  def test_browse_root
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal 9, assigns(:entries).size
                    assert assigns(:entries).detect {|e| e.name == 'images' && e.kind == 'dir'}
                    assert assigns(:entries).detect {|e| e.name == 'this_is_a_really_long_and_verbose_directory_name' && e.kind == 'dir'}
                    assert assigns(:entries).detect {|e| e.name == 'sources' && e.kind == 'dir'}
                    assert assigns(:entries).detect {|e| e.name == 'README' && e.kind == 'file'}
                    assert assigns(:entries).detect {|e| e.name == 'copied_README' && e.kind == 'file'}
                    assert assigns(:entries).detect {|e| e.name == 'new_file.txt' && e.kind == 'file'}
                    assert assigns(:entries).detect {|e| e.name == 'renamed_test.txt' && e.kind == 'file'}
                    assert assigns(:entries).detect {|e| e.name == 'filemane with spaces.txt' && e.kind == 'file'}
                    assert assigns(:entries).detect {|e| e.name == ' filename with a leading space.txt ' && e.kind == 'file'}
                    assert_not_nil assigns(:changesets)
                    assert assigns(:changesets).size > 0
                  end
                  def test_browse_branch
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID, :rev => 'test_branch'
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal 4, assigns(:entries).size
                    assert assigns(:entries).detect {|e| e.name == 'images' && e.kind == 'dir'}
                    assert assigns(:entries).detect {|e| e.name == 'sources' && e.kind == 'dir'}
                    assert assigns(:entries).detect {|e| e.name == 'README' && e.kind == 'file'}
                    assert assigns(:entries).detect {|e| e.name == 'test.txt' && e.kind == 'file'}
                    assert_not_nil assigns(:changesets)
                    assert assigns(:changesets).size > 0
                  end
                  def test_browse_tag
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                     [
                      "tag00.lightweight",
                      "tag01.annotated",
                     ].each do |t1|
                      get :show, :id => PRJ_ID, :rev => t1
                      assert_response :success
                      assert_template 'show'
                      assert_not_nil assigns(:entries)
                      assert assigns(:entries).size > 0
                      assert_not_nil assigns(:changesets)
                      assert assigns(:changesets).size > 0
                    end
                  end
                  def test_browse_directory
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID, :path => repository_path_hash(['images'])[:param]
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal ['edit.png'], assigns(:entries).collect(&:name)
                    entry = assigns(:entries).detect {|e| e.name == 'edit.png'}
                    assert_not_nil entry
                    assert_equal 'file', entry.kind
                    assert_equal 'images/edit.png', entry.path
                    assert_not_nil assigns(:changesets)
                    assert assigns(:changesets).size > 0
                  end
                  def test_browse_at_given_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID, :path => repository_path_hash(['images'])[:param],
                        :rev => '7234cb2750b63f47bff735edc50a1c0a433c2518'
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal ['delete.png'], assigns(:entries).collect(&:name)
                    assert_not_nil assigns(:changesets)
                    assert assigns(:changesets).size > 0
                  end
                  def test_changes
                    get :changes, :id => PRJ_ID,
                        :path => repository_path_hash(['images', 'edit.png'])[:param]
                    assert_response :success
                    assert_template 'changes'
                    assert_select 'h2', :text => /edit.png/
                  end
                  def test_entry_show
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]
                    assert_response :success
                    assert_template 'entry'
                    # Line 11
                    assert_select 'tr#L11 td.line-code', :text => /WITHOUT ANY WARRANTY/
                  end
                  def test_entry_show_latin_1
                    if @ruby19_non_utf8_pass
                      puts_ruby19_non_utf8_pass()
                    elsif WINDOWS_PASS
                      puts WINDOWS_SKIP_STR
                    elsif JRUBY_SKIP
                      puts JRUBY_SKIP_STR
                    else
                      with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                        ['57ca437c', '57ca437c0acbbcb749821fdf3726a1367056d364'].each do |r1|
                          get :entry, :id => PRJ_ID,
                              :path => repository_path_hash(['latin-1-dir', "test-#{CHAR_1_HEX}.txt"])[:param],
                              :rev => r1
                          assert_response :success
                          assert_template 'entry'
                          assert_select 'tr#L1 td.line-code', :text => /test-#{CHAR_1_HEX}.txt/
                        end
                      end
                    end
                  end
                  def test_entry_download
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param],
                        :format => 'raw'
                    assert_response :success
                    # File content
                    assert @response.body.include?('WITHOUT ANY WARRANTY')
                  end
                  def test_directory_entry
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['sources'])[:param]
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entry)
                    assert_equal 'sources', assigns(:entry).name
                  end
                  def test_diff
                    assert_equal true, @repository.is_default
                    assert_nil @repository.identifier
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    # Full diff of changeset 2f9c0091
                    ['inline', 'sbs'].each do |dt|
                      get :diff,
                          :id   => PRJ_ID,
                          :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',
                          :type => dt
                      assert_response :success
                      assert_template 'diff'
                      # Line 22 removed
-                     assert_select 'th.line-num:content(22) ~ td.diff_out', :text => /def remove/
+                     assert_select 'th.line-num:contains(22) ~ td.diff_out', :text => /def remove/
                      assert_select 'h2', :text => /2f9c0091/
                    end
                  end
                  def test_diff_with_rev_and_path
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    with_settings :diff_max_lines_displayed => 1000 do
                      # Full diff of changeset 2f9c0091
                      ['inline', 'sbs'].each do |dt|
                        get :diff,
                            :id   => PRJ_ID,
                            :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',
                            :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param],
                            :type => dt
                        assert_response :success
                        assert_template 'diff'
                        # Line 22 removed
-                       assert_select 'th.line-num:content(22) ~ td.diff_out', :text => /def remove/
+                       assert_select 'th.line-num:contains(22) ~ td.diff_out', :text => /def remove/
                        assert_select 'h2', :text => /2f9c0091/
                      end
                    end
                  end
                  def test_diff_truncated
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    with_settings :diff_max_lines_displayed => 5 do
                      # Truncated diff of changeset 2f9c0091
                      with_cache do
                        with_settings :default_language => 'en' do
                          get :diff, :id   => PRJ_ID, :type => 'inline',
                              :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'
                          assert_response :success
                          assert @response.body.include?("... This diff was truncated")
                        end
                        with_settings :default_language => 'fr' do
                          get :diff, :id   => PRJ_ID, :type => 'inline',
                              :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'
                          assert_response :success
                          assert ! @response.body.include?("... This diff was truncated")
                          assert @response.body.include?("... Ce diff")
                        end
                      end
                    end
                  end
                  def test_diff_two_revs
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['inline', 'sbs'].each do |dt|
                      get :diff,
                          :id     => PRJ_ID,
                          :rev    => '61b685fbe55ab05b5ac68402d5720c1a6ac973d1',
                          :rev_to => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',
                          :type   => dt
                      assert_response :success
                      assert_template 'diff'
                      diff = assigns(:diff)
                      assert_not_nil diff
                      assert_select 'h2', :text => /2f9c0091:61b685fb/
                      assert_select 'form[action=?]', '/projects/subproject1/repository/revisions/61b685fbe55ab05b5ac68402d5720c1a6ac973d1/diff'
                      assert_select 'input#rev_to[type=hidden][name=rev_to][value=?]', '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'
                    end
                  end
                  def test_diff_path_in_subrepo
                    repo = Repository::Git.create(
                                    :project       => @project,
                                    :url           => REPOSITORY_PATH,
                                    :identifier => 'test-diff-path',
                                    :path_encoding => 'ISO-8859-1'
                                    )
                    assert repo
                    assert_equal false, repo.is_default
                    assert_equal 'test-diff-path', repo.identifier
                    get :diff,
                        :id     => PRJ_ID,
                        :repository_id => 'test-diff-path',
                        :rev    => '61b685fbe55ab05b',
                        :rev_to => '2f9c0091c754a91a',
                        :type   => 'inline'
                    assert_response :success
                    assert_template 'diff'
                    diff = assigns(:diff)
                    assert_not_nil diff
                    assert_select 'form[action=?]', '/projects/subproject1/repository/test-diff-path/revisions/61b685fbe55ab05b/diff'
                    assert_select 'input#rev_to[type=hidden][name=rev_to][value=?]', '2f9c0091c754a91a'
                  end
                  def test_diff_latin_1
                    if @ruby19_non_utf8_pass
                      puts_ruby19_non_utf8_pass()
                    else
                      with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                        ['57ca437c', '57ca437c0acbbcb749821fdf3726a1367056d364'].each do |r1|
                          ['inline', 'sbs'].each do |dt|
                            get :diff, :id => PRJ_ID, :rev => r1, :type => dt
                            assert_response :success
                            assert_template 'diff'
                            assert_select 'table' do
                              assert_select 'thead th.filename', :text => /latin-1-dir\/test-#{CHAR_1_HEX}.txt/
                              assert_select 'tbody td.diff_in', :text => /test-#{CHAR_1_HEX}.txt/
                            end
                          end
                        end
                      end
                    end
                  end
                  def test_diff_should_show_filenames
                    get :diff, :id => PRJ_ID, :rev => 'deff712f05a90d96edbd70facc47d944be5897e3', :type => 'inline'
                    assert_response :success
                    assert_template 'diff'
                    # modified file
                    assert_select 'th.filename', :text => 'sources/watchers_controller.rb'
                    # deleted file
                    assert_select 'th.filename', :text => 'test.txt'
                  end
                  def test_save_diff_type
                    user1 = User.find(1)
                    user1.pref[:diff_type] = nil
                    user1.preference.save
                    user = User.find(1)
                    assert_nil user.pref[:diff_type]
                    @request.session[:user_id] = 1 # admin
                    get :diff,
                        :id   => PRJ_ID,
                        :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'
                    assert_response :success
                    assert_template 'diff'
                    user.reload
                    assert_equal "inline", user.pref[:diff_type]
                    get :diff,
                        :id   => PRJ_ID,
                        :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',
                        :type => 'sbs'
                    assert_response :success
                    assert_template 'diff'
                    user.reload
                    assert_equal "sbs", user.pref[:diff_type]
                  end
                  def test_annotate
                    get :annotate, :id => PRJ_ID,
                        :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]
                    assert_response :success
                    assert_template 'annotate'
                    # Line 23, changeset 2f9c0091
                    assert_select 'tr' do
                      assert_select 'th.line-num', :text => '23'
                      assert_select 'td.revision', :text => /2f9c0091/
                      assert_select 'td.author', :text => 'jsmith'
                      assert_select 'td', :text => /remove_watcher/
                    end
                  end
                  def test_annotate_at_given_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :annotate, :id => PRJ_ID, :rev => 'deff7',
                        :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]
                    assert_response :success
                    assert_template 'annotate'
                    assert_select 'h2', :text => /@ deff712f/
                  end
                  def test_annotate_binary_file
                    with_settings :default_language => 'en' do
                      get :annotate, :id => PRJ_ID,
                          :path => repository_path_hash(['images', 'edit.png'])[:param]
                      assert_response 500
                      assert_select 'p#errorExplanation', :text => /cannot be annotated/
                    end
                  end
                  def test_annotate_error_when_too_big
                    with_settings :file_max_size_displayed => 1 do
                      get :annotate, :id => PRJ_ID,
                          :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param],
                          :rev => 'deff712f'
                      assert_response 500
                      assert_select 'p#errorExplanation', :text => /exceeds the maximum text file size/
                      get :annotate, :id => PRJ_ID,
                          :path => repository_path_hash(['README'])[:param],
                          :rev => '7234cb2'
                      assert_response :success
                      assert_template 'annotate'
                    end
                  end
                  def test_annotate_latin_1
                    if @ruby19_non_utf8_pass
                      puts_ruby19_non_utf8_pass()
                    elsif WINDOWS_PASS
                      puts WINDOWS_SKIP_STR
                    elsif JRUBY_SKIP
                      puts JRUBY_SKIP_STR
                    else
                      with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                        ['57ca437c', '57ca437c0acbbcb749821fdf3726a1367056d364'].each do |r1|
                          get :annotate, :id => PRJ_ID,
                              :path => repository_path_hash(['latin-1-dir', "test-#{CHAR_1_HEX}.txt"])[:param],
                              :rev => r1
                          assert_select "th.line-num", :text => '1' do
                            assert_select "+ td.revision" do
                              assert_select "a", :text => '57ca437c'
                              assert_select "+ td.author", :text => "jsmith" do
                                assert_select "+ td",
                                              :text => "test-#{CHAR_1_HEX}.txt"
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                  def test_annotate_latin_1_author
                    ['83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', '83ca5fd546063a'].each do |r1|
                      get :annotate, :id => PRJ_ID,
                          :path => repository_path_hash([" filename with a leading space.txt "])[:param],
                          :rev => r1
                      assert_select "th.line-num", :text => '1' do
                        assert_select "+ td.revision" do
                          assert_select "a", :text => '83ca5fd5'
                          assert_select "+ td.author", :text => FELIX_HEX do
                            assert_select "+ td",
                                          :text => "And this is a file with a leading and trailing space..."
                          end
                        end
                      end
                    end
                  end
                  def test_revisions
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :revisions, :id => PRJ_ID
                    assert_response :success
                    assert_template 'revisions'
                    assert_select 'form[method=get][action=?]', '/projects/subproject1/repository/revision'
                  end
                  def test_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['61b685fbe55ab05b5ac68402d5720c1a6ac973d1', '61b685f'].each do |r|
                      get :revision, :id => PRJ_ID, :rev => r
                      assert_response :success
                      assert_template 'revision'
                    end
                  end
                  def test_empty_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['', ' ', nil].each do |r|
                      get :revision, :id => PRJ_ID, :rev => r
                      assert_response 404
                      assert_select_error /was not found/
                    end
                  end
                  def test_destroy_valid_repository
                    @request.session[:user_id] = 1 # admin
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_difference 'Repository.count', -1 do
                      delete :destroy, :id => @repository.id
                    end
                    assert_response 302
                    @project.reload
                    assert_nil @project.repository
                  end
                  def test_destroy_invalid_repository
                    @request.session[:user_id] = 1 # admin
                    @project.repository.destroy
                    @repository = Repository::Git.create!(
                                    :project       => @project,
                                    :url           => "/invalid",
                                    :path_encoding => 'ISO-8859-1'
                                    )
                    @repository.fetch_changesets
                    @repository.reload
                    assert_equal 0, @repository.changesets.count
                    assert_difference 'Repository.count', -1 do
                      delete :destroy, :id => @repository.id
                    end
                    assert_response 302
                    @project.reload
                    assert_nil @project.repository
                  end
                  private
                  def puts_ruby19_non_utf8_pass
                    puts "TODO: This test fails " +
                         "when Encoding.default_external is not UTF-8. " +
                         "Current value is '#{Encoding.default_external.to_s}'"
                  end
                else
                  puts "Git test repository NOT FOUND. Skipping functional tests !!!"
                  def test_fake; assert true end
                end
                private
                def with_cache(&block)
                  before = ActionController::Base.perform_caching
                  ActionController::Base.perform_caching = true
                  block.call
                  ActionController::Base.perform_caching = before
                end
              end

test/functional/repositories_mercurial_controller_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 RepositoriesMercurialControllerTest < ActionController::TestCase
                tests RepositoriesController
                fixtures :projects, :users, :email_addresses, :roles, :members, :member_roles,
                         :repositories, :enabled_modules
                REPOSITORY_PATH = Rails.root.join('tmp/test/mercurial_repository').to_s
                CHAR_1_HEX = "\xc3\x9c"
                PRJ_ID     = 3
                NUM_REV    = 34
                ruby19_non_utf8_pass = Encoding.default_external.to_s != 'UTF-8'
                def setup
                  User.current = nil
                  @project    = Project.find(PRJ_ID)
                  @repository = Repository::Mercurial.create(
                                    :project => @project,
                                    :url     => REPOSITORY_PATH,
                                    :path_encoding => 'ISO-8859-1'
                                    )
                  assert @repository
                  @diff_c_support = true
                  @char_1        = CHAR_1_HEX.dup.force_encoding('UTF-8')
                  @tag_char_1    = "tag-#{CHAR_1_HEX}-00".force_encoding('UTF-8')
                  @branch_char_0 = "branch-#{CHAR_1_HEX}-00".force_encoding('UTF-8')
                  @branch_char_1 = "branch-#{CHAR_1_HEX}-01".force_encoding('UTF-8')
                end
                if ruby19_non_utf8_pass
                  puts "TODO: Mercurial functional test fails " +
                       "when Encoding.default_external is not UTF-8. " +
                       "Current value is '#{Encoding.default_external.to_s}'"
                  def test_fake; assert true end
                elsif File.directory?(REPOSITORY_PATH)
                  def test_get_new
                    @request.session[:user_id] = 1
                    @project.repository.destroy
                    get :new, :project_id => 'subproject1', :repository_scm => 'Mercurial'
                    assert_response :success
                    assert_template 'new'
                    assert_kind_of Repository::Mercurial, assigns(:repository)
                    assert assigns(:repository).new_record?
                  end
                  def test_show_root
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal 4, assigns(:entries).size
                    assert assigns(:entries).detect {|e| e.name == 'images'  && e.kind == 'dir'}
                    assert assigns(:entries).detect {|e| e.name == 'sources' && e.kind == 'dir'}
                    assert assigns(:entries).detect {|e| e.name == 'README'  && e.kind == 'file'}
                    assert_not_nil assigns(:changesets)
                    assert assigns(:changesets).size > 0
                  end
                  def test_show_directory
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID, :path => repository_path_hash(['images'])[:param]
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entries)
                    assert_equal ['delete.png', 'edit.png'], assigns(:entries).collect(&:name)
                    entry = assigns(:entries).detect {|e| e.name == 'edit.png'}
                    assert_not_nil entry
                    assert_equal 'file', entry.kind
                    assert_equal 'images/edit.png', entry.path
                    assert_not_nil assigns(:changesets)
                    assert assigns(:changesets).size > 0
                  end
                  def test_show_at_given_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    [0, '0', '0885933ad4f6'].each do |r1|
                      get :show, :id => PRJ_ID, :path => repository_path_hash(['images'])[:param],
                          :rev => r1
                      assert_response :success
                      assert_template 'show'
                      assert_not_nil assigns(:entries)
                      assert_equal ['delete.png'], assigns(:entries).collect(&:name)
                      assert_not_nil assigns(:changesets)
                      assert assigns(:changesets).size > 0
                    end
                  end
                  def test_show_directory_sql_escape_percent
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    [13, '13', '3a330eb32958'].each do |r1|
                      get :show, :id => PRJ_ID,
                          :path => repository_path_hash(['sql_escape', 'percent%dir'])[:param],
                          :rev => r1
                      assert_response :success
                      assert_template 'show'
                      assert_not_nil assigns(:entries)
                      assert_equal ['percent%file1.txt', 'percentfile1.txt'],
                                   assigns(:entries).collect(&:name)
                      changesets = assigns(:changesets)
                      assert_not_nil changesets
                      assert assigns(:changesets).size > 0
                      assert_equal %w(13 11 10 9), changesets.collect(&:revision)
                    end
                  end
                  def test_show_directory_latin_1_path
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    [21, '21', 'adf805632193'].each do |r1|
                      get :show, :id => PRJ_ID,
                          :path => repository_path_hash(['latin-1-dir'])[:param],
                          :rev => r1
                      assert_response :success
                      assert_template 'show'
                      assert_not_nil assigns(:entries)
                      assert_equal ["make-latin-1-file.rb",
                                    "test-#{@char_1}-1.txt",
                                    "test-#{@char_1}-2.txt",
                                    "test-#{@char_1}.txt"], assigns(:entries).collect(&:name)
                      changesets = assigns(:changesets)
                      assert_not_nil changesets
                      assert_equal %w(21 20 19 18 17), changesets.collect(&:revision)
                    end
                  end
                  def show_should_show_branch_selection_form
                    @repository.fetch_changesets
                    @project.reload
                    get :show, :id => PRJ_ID
                    assert_select 'form#revision_selector[action=?]', '/projects/subproject1/repository/show' do
                      assert_select 'select[name=branch]' do
                        assert_select 'option[value=?]', 'test-branch-01'
                      end
                    end
                  end
                  def test_show_branch
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                     [
                        'default',
                        @branch_char_1,
                        'branch (1)[2]&,%.-3_4',
                        @branch_char_0,
                        'test_branch.latin-1',
                        'test-branch-00',
                    ].each do |bra|
                      get :show, :id => PRJ_ID, :rev => bra
                      assert_response :success
                      assert_template 'show'
                      assert_not_nil assigns(:entries)
                      assert assigns(:entries).size > 0
                      assert_not_nil assigns(:changesets)
                      assert assigns(:changesets).size > 0
                    end
                  end
                  def test_show_tag
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                     [
                      @tag_char_1,
                      'tag_test.00',
                      'tag-init-revision'
                    ].each do |tag|
                      get :show, :id => PRJ_ID, :rev => tag
                      assert_response :success
                      assert_template 'show'
                      assert_not_nil assigns(:entries)
                      assert assigns(:entries).size > 0
                      assert_not_nil assigns(:changesets)
                      assert assigns(:changesets).size > 0
                    end
                  end
                  def test_changes
                    get :changes, :id => PRJ_ID,
                        :path => repository_path_hash(['images', 'edit.png'])[:param]
                    assert_response :success
                    assert_template 'changes'
                    assert_select 'h2', :text => /edit.png/
                  end
                  def test_entry_show
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]
                    assert_response :success
                    assert_template 'entry'
                    # Line 10
                    assert_select 'tr#L10 td.line-code', :text => /WITHOUT ANY WARRANTY/
                  end
                  def test_entry_show_latin_1_path
                    [21, '21', 'adf805632193'].each do |r1|
                      get :entry, :id => PRJ_ID,
                          :path => repository_path_hash(['latin-1-dir', "test-#{@char_1}-2.txt"])[:param],
                          :rev => r1
                      assert_response :success
                      assert_template 'entry'
                      assert_select 'tr#L1 td.line-code', :text => /Mercurial is a distributed version control system/
                    end
                  end
                  def test_entry_show_latin_1_contents
                    with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                      [27, '27', '7bbf4c738e71'].each do |r1|
                        get :entry, :id => PRJ_ID,
                            :path => repository_path_hash(['latin-1-dir', "test-#{@char_1}.txt"])[:param],
                            :rev => r1
                        assert_response :success
                        assert_template 'entry'
                        assert_select 'tr#L1 td.line-code', :text => /test-#{@char_1}.txt/
                      end
                    end
                  end
                  def test_entry_download
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param],
                        :format => 'raw'
                    assert_response :success
                    # File content
                    assert @response.body.include?('WITHOUT ANY WARRANTY')
                  end
                  def test_entry_binary_force_download
                    get :entry, :id => PRJ_ID, :rev => 1,
                        :path => repository_path_hash(['images', 'edit.png'])[:param]
                    assert_response :success
                    assert_equal 'image/png', @response.content_type
                  end
                  def test_directory_entry
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['sources'])[:param]
                    assert_response :success
                    assert_template 'show'
                    assert_not_nil assigns(:entry)
                    assert_equal 'sources', assigns(:entry).name
                  end
                  def test_diff
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    [4, '4', 'def6d2f1254a'].each do |r1|
                      # Full diff of changeset 4
                      ['inline', 'sbs'].each do |dt|
                        get :diff, :id => PRJ_ID, :rev => r1, :type => dt
                        assert_response :success
                        assert_template 'diff'
                        if @diff_c_support
                          # Line 22 removed
-                         assert_select 'th.line-num:content(22) ~ td.diff_out', :text => /def remove/
+                         assert_select 'th.line-num:contains(22) ~ td.diff_out', :text => /def remove/
                          assert_select 'h2', :text => /4:def6d2f1254a/
                        end
                      end
                    end
                  end
                  def test_diff_two_revs
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    [2, '400bb8672109', '400', 400].each do |r1|
                      [4, 'def6d2f1254a'].each do |r2|
                        ['inline', 'sbs'].each do |dt|
                          get :diff,
                              :id     => PRJ_ID,
                              :rev    => r1,
                              :rev_to => r2,
                              :type => dt
                          assert_response :success
                          assert_template 'diff'
                          diff = assigns(:diff)
                          assert_not_nil diff
                          assert_select 'h2', :text => /4:def6d2f1254a 2:400bb8672109/
                        end
                      end
                    end
                  end
                  def test_diff_latin_1_path
                    with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                      [21, 'adf805632193'].each do |r1|
                        ['inline', 'sbs'].each do |dt|
                          get :diff, :id => PRJ_ID, :rev => r1, :type => dt
                          assert_response :success
                          assert_template 'diff'
                          assert_select 'table' do
                            assert_select 'thead th.filename', :text => /latin-1-dir\/test-#{@char_1}-2.txt/
                            assert_select 'tbody td.diff_in', :text => /It is written in Python/
                          end
                        end
                      end
                    end
                  end
                  def test_diff_should_show_modified_filenames
                    get :diff, :id => PRJ_ID, :rev => '400bb8672109', :type => 'inline'
                    assert_response :success
                    assert_template 'diff'
                    assert_select 'th.filename', :text => 'sources/watchers_controller.rb'
                  end
                  def test_diff_should_show_deleted_filenames
                    get :diff, :id => PRJ_ID, :rev => 'b3a615152df8', :type => 'inline'
                    assert_response :success
                    assert_template 'diff'
                    assert_select 'th.filename', :text => 'sources/welcome_controller.rb'
                  end
                  def test_annotate
                    get :annotate, :id => PRJ_ID,
                        :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]
                    assert_response :success
                    assert_template 'annotate'
                    # Line 22, revision 4:def6d2f1254a
                    assert_select 'tr' do
                      assert_select 'th.line-num', :text => '22'
                      assert_select 'td.revision', :text => '4:def6d2f1254a'
                      assert_select 'td.author', :text => 'jsmith'
                      assert_select 'td', :text => /remove_watcher/
                    end
                  end
                  def test_annotate_not_in_tip
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :annotate, :id => PRJ_ID,
                        :path => repository_path_hash(['sources', 'welcome_controller.rb'])[:param]
                    assert_response 404
                    assert_select_error /was not found/
                  end
                  def test_annotate_at_given_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    [2, '400bb8672109', '400', 400].each do |r1|
                      get :annotate, :id => PRJ_ID, :rev => r1,
                          :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]
                      assert_response :success
                      assert_template 'annotate'
                      assert_select 'h2', :text => /@ 2:400bb8672109/
                    end
                  end
                  def test_annotate_latin_1_path
                    [21, '21', 'adf805632193'].each do |r1|
                      get :annotate, :id => PRJ_ID,
                          :path => repository_path_hash(['latin-1-dir', "test-#{@char_1}-2.txt"])[:param],
                          :rev => r1
                      assert_response :success
                      assert_template 'annotate'
                      assert_select "th.line-num", :text => '1' do
                        assert_select "+ td.revision" do
                          assert_select "a", :text => '20:709858aafd1b'
                          assert_select "+ td.author", :text => "jsmith" do
                            assert_select "+ td",
                                          :text => "Mercurial is a distributed version control system."
                          end
                        end
                      end
                    end
                  end
                  def test_annotate_latin_1_contents
                    with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                      [27, '7bbf4c738e71'].each do |r1|
                        get :annotate, :id => PRJ_ID,
                            :path => repository_path_hash(['latin-1-dir', "test-#{@char_1}.txt"])[:param],
                            :rev => r1
                        assert_select 'tr#L1 td.line-code', :text => /test-#{@char_1}.txt/
                      end
                    end
                  end
                  def test_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['1', '9d5b5b', '9d5b5b004199'].each do |r|
                      with_settings :default_language => "en" do
                        get :revision, :id => PRJ_ID, :rev => r
                        assert_response :success
                        assert_template 'revision'
                        assert_select 'title',
                                      :text => 'Revision 1:9d5b5b004199 - Added 2 files and modified one. - eCookbook Subproject 1 - Redmine'
                        end
                    end
                  end
                  def test_empty_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['', ' ', nil].each do |r|
                      get :revision, :id => PRJ_ID, :rev => r
                      assert_response 404
                      assert_select_error /was not found/
                    end
                  end
                  def test_destroy_valid_repository
                    @request.session[:user_id] = 1 # admin
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_difference 'Repository.count', -1 do
                      delete :destroy, :id => @repository.id
                    end
                    assert_response 302
                    @project.reload
                    assert_nil @project.repository
                  end
                  def test_destroy_invalid_repository
                    @request.session[:user_id] = 1 # admin
                    @project.repository.destroy
                    @repository = Repository::Mercurial.create!(
                                    :project => Project.find(PRJ_ID),
                                    :url     => "/invalid",
                                    :path_encoding => 'ISO-8859-1'
                                    )
                    @repository.fetch_changesets
                    assert_equal 0, @repository.changesets.count
                    assert_difference 'Repository.count', -1 do
                      delete :destroy, :id => @repository.id
                    end
                    assert_response 302
                    @project.reload
                    assert_nil @project.repository
                  end
                else
                  puts "Mercurial test repository NOT FOUND. Skipping functional tests !!!"
                  def test_fake; assert true end
                end
              end

test/functional/search_controller_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 SearchControllerTest < ActionController::TestCase
                fixtures :projects, :projects_trackers,
                         :enabled_modules, :roles, :users, :members, :member_roles,
                         :issues, :trackers, :issue_statuses, :enumerations,
                         :workflows,
                         :custom_fields, :custom_values,
                         :custom_fields_projects, :custom_fields_trackers,
                         :repositories, :changesets
                def setup
                  User.current = nil
                end
                def test_search_for_projects
                  get :index
                  assert_response :success
                  assert_template 'index'
                  get :index, :q => "cook"
                  assert_response :success
                  assert_template 'index'
                  assert assigns(:results).include?(Project.find(1))
                end
                def test_search_on_archived_project_should_return_404
                  Project.find(3).archive
                  get :index, :id => 3
                  assert_response 404
                end
                def test_search_on_invisible_project_by_user_should_be_denied
                  @request.session[:user_id] = 7
                  get :index, :id => 2
                  assert_response 403
                end
                def test_search_on_invisible_project_by_anonymous_user_should_redirect
                  get :index, :id => 2
                  assert_response 302
                end
                def test_search_on_private_project_by_member_should_succeed
                  @request.session[:user_id] = 2
                  get :index, :id => 2
                  assert_response :success
                end
                def test_search_all_projects
                  with_settings :default_language => 'en' do
                    get :index, :q => 'recipe subproject commit', :all_words => ''
                  end
                  assert_response :success
                  assert_template 'index'
                  assert assigns(:results).include?(Issue.find(2))
                  assert assigns(:results).include?(Issue.find(5))
                  assert assigns(:results).include?(Changeset.find(101))
                  assert_select 'dt.issue a', :text => /Add ingredients categories/
                  assert_select 'dd', :text => /should be classified by categories/
                  assert assigns(:result_count_by_type).is_a?(Hash)
                  assert_equal 5, assigns(:result_count_by_type)['changesets']
                  assert_select 'a', :text => 'Changesets (5)'
                end
                def test_search_issues
                  get :index, :q => 'issue', :issues => 1
                  assert_response :success
                  assert_template 'index'
                  assert_equal true, assigns(:all_words)
                  assert_equal false, assigns(:titles_only)
                  assert assigns(:results).include?(Issue.find(8))
                  assert assigns(:results).include?(Issue.find(5))
                  assert_select 'dt.issue.closed a',  :text => /Closed/
                end
                def test_search_issues_should_search_notes
                  Journal.create!(:journalized => Issue.find(2), :notes => 'Issue notes with searchkeyword')
                  get :index, :q => 'searchkeyword', :issues => 1
                  assert_response :success
                  assert_include Issue.find(2), assigns(:results)
                end
                def test_search_issues_with_multiple_matches_in_journals_should_return_issue_once
                  Journal.create!(:journalized => Issue.find(2), :notes => 'Issue notes with searchkeyword')
                  Journal.create!(:journalized => Issue.find(2), :notes => 'Issue notes with searchkeyword')
                  get :index, :q => 'searchkeyword', :issues => 1
                  assert_response :success
                  assert_include Issue.find(2), assigns(:results)
                  assert_equal 1, assigns(:results).size
                end
                def test_search_issues_should_search_private_notes_with_permission_only
                  Journal.create!(:journalized => Issue.find(2), :notes => 'Private notes with searchkeyword', :private_notes => true)
                  @request.session[:user_id] = 2
                  Role.find(1).add_permission! :view_private_notes
                  get :index, :q => 'searchkeyword', :issues => 1
                  assert_response :success
                  assert_include Issue.find(2), assigns(:results)
                  Role.find(1).remove_permission! :view_private_notes
                  get :index, :q => 'searchkeyword', :issues => 1
                  assert_response :success
                  assert_not_include Issue.find(2), assigns(:results)
                end
                def test_search_all_projects_with_scope_param
                  get :index, :q => 'issue', :scope => 'all'
                  assert_response :success
                  assert_template 'index'
                  assert assigns(:results).present?
                end
                def test_search_my_projects
                  @request.session[:user_id] = 2
                  get :index, :id => 1, :q => 'recipe subproject', :scope => 'my_projects', :all_words => ''
                  assert_response :success
                  assert_template 'index'
                  assert assigns(:results).include?(Issue.find(1))
                  assert !assigns(:results).include?(Issue.find(5))
                end
                def test_search_my_projects_without_memberships
                  # anonymous user has no memberships
                  get :index, :id => 1, :q => 'recipe subproject', :scope => 'my_projects', :all_words => ''
                  assert_response :success
                  assert_template 'index'
                  assert assigns(:results).empty?
                end
                def test_search_project_and_subprojects
                  get :index, :id => 1, :q => 'recipe subproject', :scope => 'subprojects', :all_words => ''
                  assert_response :success
                  assert_template 'index'
                  assert assigns(:results).include?(Issue.find(1))
                  assert assigns(:results).include?(Issue.find(5))
                end
                def test_search_without_searchable_custom_fields
                  CustomField.update_all "searchable = #{ActiveRecord::Base.connection.quoted_false}"
                  get :index, :id => 1
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:project)
                  get :index, :id => 1, :q => "can"
                  assert_response :success
                  assert_template 'index'
                end
                def test_search_with_searchable_custom_fields
                  get :index, :id => 1, :q => "stringforcustomfield"
                  assert_response :success
                  results = assigns(:results)
                  assert_not_nil results
                  assert_equal 1, results.size
                  assert results.include?(Issue.find(7))
                end
                def test_search_without_attachments
                  issue = Issue.generate! :subject => 'search_attachments'
                  attachment = Attachment.generate! :container => Issue.find(1), :filename => 'search_attachments.patch'
                  get :index, :id => 1, :q => 'search_attachments', :attachments => '0'
                  results = assigns(:results)
                  assert_equal 1, results.size
                  assert_equal issue, results.first
                end
                def test_search_attachments_only
                  issue = Issue.generate! :subject => 'search_attachments'
                  attachment = Attachment.generate! :container => Issue.find(1), :filename => 'search_attachments.patch'
                  get :index, :id => 1, :q => 'search_attachments', :attachments => 'only'
                  results = assigns(:results)
                  assert_equal 1, results.size
                  assert_equal attachment.container, results.first
                end
                def test_search_with_attachments
                  Issue.generate! :subject => 'search_attachments'
                  Attachment.generate! :container => Issue.find(1), :filename => 'search_attachments.patch'
                  get :index, :id => 1, :q => 'search_attachments', :attachments => '1'
                  results = assigns(:results)
                  assert_equal 2, results.size
                end
                def test_search_open_issues
                  Issue.generate! :subject => 'search_open'
                  Issue.generate! :subject => 'search_open', :status_id => 5
                  get :index, :id => 1, :q => 'search_open', :open_issues => '1'
                  results = assigns(:results)
                  assert_equal 1, results.size
                end
                def test_search_all_words
                  # 'all words' is on by default
                  get :index, :id => 1, :q => 'recipe updating saving', :all_words => '1'
                  assert_equal true, assigns(:all_words)
                  results = assigns(:results)
                  assert_not_nil results
                  assert_equal 1, results.size
                  assert results.include?(Issue.find(3))
                end
                def test_search_one_of_the_words
                  get :index, :id => 1, :q => 'recipe updating saving', :all_words => ''
                  assert_equal false, assigns(:all_words)
                  results = assigns(:results)
                  assert_not_nil results
                  assert_equal 3, results.size
                  assert results.include?(Issue.find(3))
                end
                def test_search_titles_only_without_result
                  get :index, :id => 1, :q => 'recipe updating saving', :titles_only => '1'
                  results = assigns(:results)
                  assert_not_nil results
                  assert_equal 0, results.size
                end
                def test_search_titles_only
                  get :index, :id => 1, :q => 'recipe', :titles_only => '1'
                  assert_equal true, assigns(:titles_only)
                  results = assigns(:results)
                  assert_not_nil results
                  assert_equal 2, results.size
                end
                def test_search_content
                  Issue.where(:id => 1).update_all("description = 'This is a searchkeywordinthecontent'")
                  get :index, :id => 1, :q => 'searchkeywordinthecontent', :titles_only => ''
                  assert_equal false, assigns(:titles_only)
                  results = assigns(:results)
                  assert_not_nil results
                  assert_equal 1, results.size
                end
                def test_search_with_pagination
                  issue = (0..24).map {Issue.generate! :subject => 'search_with_limited_results'}.reverse
                  get :index, :q => 'search_with_limited_results'
                  assert_response :success
                  assert_equal issue[0..9], assigns(:results)
                  get :index, :q => 'search_with_limited_results', :page => 2
                  assert_response :success
                  assert_equal issue[10..19], assigns(:results)
                  get :index, :q => 'search_with_limited_results', :page => 3
                  assert_response :success
                  assert_equal issue[20..24], assigns(:results)
                  get :index, :q => 'search_with_limited_results', :page => 4
                  assert_response :success
                  assert_equal [], assigns(:results)
                end
                def test_search_with_invalid_project_id
                  get :index, :id => 195, :q => 'recipe'
                  assert_response 404
                  assert_nil assigns(:results)
                end
                def test_quick_jump_to_issue
                  # issue of a public project
                  get :index, :q => "3"
                  assert_redirected_to '/issues/3'
                  # issue of a private project
                  get :index, :q => "4"
                  assert_response :success
                  assert_template 'index'
                end
                def test_large_integer
                  get :index, :q => '4615713488'
                  assert_response :success
                  assert_template 'index'
                end
                def test_tokens_with_quotes
                  get :index, :id => 1, :q => '"good bye" hello "bye bye"'
                  assert_equal ["good bye", "hello", "bye bye"], assigns(:tokens)
                end
                def test_results_should_be_escaped_once
                  assert Issue.find(1).update_attributes(:subject => '<subject> escaped_once', :description => '<description> escaped_once')
                  get :index, :q => 'escaped_once'
                  assert_response :success
                  assert_select '#search-results' do
-                   assert_select 'dt.issue a', :text => /&lt;subject&gt;/
-                   assert_select 'dd', :text => /&lt;description&gt;/
+                   assert_select 'dt.issue a', :text => /<subject>/
+                   assert_select 'dd', :text => /<description>/
                  end
                end
                def test_keywords_should_be_highlighted
                  assert Issue.find(1).update_attributes(:subject => 'subject highlighted', :description => 'description highlighted')
                  get :index, :q => 'highlighted'
                  assert_response :success
                  assert_select '#search-results' do
                    assert_select 'dt.issue a span.highlight', :text => 'highlighted'
                    assert_select 'dd span.highlight', :text => 'highlighted'
                  end
                end
              end

test/functional/settings_controller_test.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 SettingsControllerTest < ActionController::TestCase
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :users
                def setup
                  User.current = nil
                  @request.session[:user_id] = 1 # admin
                end
                def test_index
                  get :index
                  assert_response :success
                  assert_template 'edit'
                end
                def test_get_edit
                  get :edit
                  assert_response :success
                  assert_template 'edit'
                  assert_select 'input[name=?][value=""]', 'settings[enabled_scm][]'
                end
                def test_get_edit_should_preselect_default_issue_list_columns
                  with_settings :issue_list_default_columns => %w(tracker subject status updated_on) do
                    get :edit
                    assert_response :success
                  end
                  assert_select 'select[id=selected_columns][name=?]', 'settings[issue_list_default_columns][]' do
                    assert_select 'option', 4
                    assert_select 'option[value=tracker]', :text => 'Tracker'
                    assert_select 'option[value=subject]', :text => 'Subject'
                    assert_select 'option[value=status]', :text => 'Status'
                    assert_select 'option[value=updated_on]', :text => 'Updated'
                  end
                  assert_select 'select[id=available_columns]' do
                    assert_select 'option[value=tracker]', 0
                    assert_select 'option[value=priority]', :text => 'Priority'
                  end
                end
                def test_get_edit_without_trackers_should_succeed
                  Tracker.delete_all
                  get :edit
                  assert_response :success
                end
                def test_post_edit_notifications
                  post :edit, :settings => {:mail_from => 'functional@test.foo',
                                            :bcc_recipients  => '0',
                                            :notified_events => %w(issue_added issue_updated news_added),
                                            :emails_footer => 'Test footer'
                                            }
                  assert_redirected_to '/settings'
                  assert_equal 'functional@test.foo', Setting.mail_from
                  assert !Setting.bcc_recipients?
                  assert_equal %w(issue_added issue_updated news_added), Setting.notified_events
                  assert_equal 'Test footer', Setting.emails_footer
                  Setting.clear_cache
                end
                def test_edit_commit_update_keywords
                  with_settings :commit_update_keywords => [
                    {"keywords" => "fixes, resolves", "status_id" => "3"},
                    {"keywords" => "closes", "status_id" => "5", "done_ratio" => "100", "if_tracker_id" => "2"}
                  ] do
                    get :edit
                  end
                  assert_response :success
                  assert_select 'tr.commit-keywords', 2
                  assert_select 'tr.commit-keywords:nth-child(1)' do
                    assert_select 'input[name=?][value=?]', 'settings[commit_update_keywords][keywords][]', 'fixes, resolves'
                    assert_select 'select[name=?]', 'settings[commit_update_keywords][status_id][]' do
                      assert_select 'option[value="3"][selected=selected]'
                    end
                  end
                  assert_select 'tr.commit-keywords:nth-child(2)' do
                    assert_select 'input[name=?][value=?]', 'settings[commit_update_keywords][keywords][]', 'closes'
                    assert_select 'select[name=?]', 'settings[commit_update_keywords][status_id][]' do
                      assert_select 'option[value="5"][selected=selected]', :text => 'Closed'
                    end
                    assert_select 'select[name=?]', 'settings[commit_update_keywords][done_ratio][]' do
                      assert_select 'option[value="100"][selected=selected]', :text => '100 %'
                    end
                    assert_select 'select[name=?]', 'settings[commit_update_keywords][if_tracker_id][]' do
                      assert_select 'option[value="2"][selected=selected]', :text => 'Feature request'
                    end
                  end
                end
                def test_edit_without_commit_update_keywords_should_show_blank_line
                  with_settings :commit_update_keywords => [] do
                    get :edit
                  end
                  assert_response :success
                  assert_select 'tr.commit-keywords', 1 do
                    assert_select 'input[name=?]:not([value])', 'settings[commit_update_keywords][keywords][]'
                  end
                end
                def test_post_edit_commit_update_keywords
                  post :edit, :settings => {
                    :commit_update_keywords => {
                      :keywords => ["resolves", "closes"],
                      :status_id => ["3", "5"],
                      :done_ratio => ["", "100"],
                      :if_tracker_id => ["", "2"]
                    }
                  }
                  assert_redirected_to '/settings'
                  assert_equal([
                    {"keywords" => "resolves", "status_id" => "3"},
                    {"keywords" => "closes", "status_id" => "5", "done_ratio" => "100", "if_tracker_id" => "2"}
                  ], Setting.commit_update_keywords)
                end
                def test_get_plugin_settings
                  ActionController::Base.append_view_path(File.join(Rails.root, "test/fixtures/plugins"))
                  Redmine::Plugin.register :foo do
-                   settings :partial => "foo_plugin/foo_plugin_settings",
-                     :default => {'sample_setting' => 'Plugin setting value'}
+                   settings :partial => "foo_plugin/foo_plugin_settings"
                  end
+                 Setting.plugin_foo = {'sample_setting' => 'Plugin setting value'}
                  get :plugin, :id => 'foo'
                  assert_response :success
                  assert_template 'plugin'
                  assert_select 'form[action="/settings/plugin/foo"]' do
                    assert_select 'input[name=?][value=?]', 'settings[sample_setting]', 'Plugin setting value'
                  end
                ensure
                  Redmine::Plugin.unregister(:foo)
                end
                def test_get_invalid_plugin_settings
                  get :plugin, :id => 'none'
                  assert_response 404
                end
                def test_get_non_configurable_plugin_settings
                  Redmine::Plugin.register(:foo) {}
                  get :plugin, :id => 'foo'
                  assert_response 404
                ensure
                  Redmine::Plugin.unregister(:foo)
                end
                def test_post_plugin_settings
                  Redmine::Plugin.register(:foo) do
                    settings :partial => 'not blank', # so that configurable? is true
                      :default => {'sample_setting' => 'Plugin setting value'}
                  end
                  post :plugin, :id => 'foo', :settings => {'sample_setting' => 'Value'}
                  assert_redirected_to '/settings/plugin/foo'
                  assert_equal({'sample_setting' => 'Value'}, Setting.plugin_foo)
                end
                def test_post_non_configurable_plugin_settings
                  Redmine::Plugin.register(:foo) {}
                  post :plugin, :id => 'foo', :settings => {'sample_setting' => 'Value'}
                  assert_response 404
                ensure
                  Redmine::Plugin.unregister(:foo)
                end
              end

test/functional/timelog_controller_test.rb +1 -1

              # -*- coding: utf-8 -*-
              # Redmine - project management software
              # Copyright (C) 2006-2015  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 TimelogControllerTest < ActionController::TestCase
                fixtures :projects, :enabled_modules, :roles, :members,
                         :member_roles, :issues, :time_entries, :users,
                         :trackers, :enumerations, :issue_statuses,
                         :custom_fields, :custom_values,
                         :projects_trackers, :custom_fields_trackers,
                         :custom_fields_projects
                include Redmine::I18n
                def test_new
                  @request.session[:user_id] = 3
                  get :new
                  assert_response :success
                  assert_template 'new'
                  assert_select 'input[name=?][type=hidden]', 'project_id', 0
                  assert_select 'input[name=?][type=hidden]', 'issue_id', 0
                  assert_select 'select[name=?]', 'time_entry[project_id]' do
                    # blank option for project
                    assert_select 'option[value=""]'
                  end
                end
                def test_new_with_project_id
                  @request.session[:user_id] = 3
                  get :new, :project_id => 1
                  assert_response :success
                  assert_template 'new'
                  assert_select 'input[name=?][type=hidden]', 'project_id'
                  assert_select 'input[name=?][type=hidden]', 'issue_id', 0
                  assert_select 'select[name=?]', 'time_entry[project_id]', 0
                end
                def test_new_with_issue_id
                  @request.session[:user_id] = 3
                  get :new, :issue_id => 2
                  assert_response :success
                  assert_template 'new'
                  assert_select 'input[name=?][type=hidden]', 'project_id', 0
                  assert_select 'input[name=?][type=hidden]', 'issue_id'
                  assert_select 'select[name=?]', 'time_entry[project_id]', 0
                end
                def test_new_without_project_should_prefill_the_form
                  @request.session[:user_id] = 3
                  get :new, :time_entry => {:project_id => '1'}
                  assert_response :success
                  assert_template 'new'
                  assert_select 'select[name=?]', 'time_entry[project_id]' do
                    assert_select 'option[value="1"][selected=selected]'
                  end
                end
                def test_new_without_project_should_deny_without_permission
                  Role.all.each {|role| role.remove_permission! :log_time}
                  @request.session[:user_id] = 3
                  get :new
                  assert_response 403
                end
                def test_new_should_select_default_activity
                  @request.session[:user_id] = 3
                  get :new, :project_id => 1
                  assert_response :success
                  assert_select 'select[name=?]', 'time_entry[activity_id]' do
                    assert_select 'option[selected=selected]', :text => 'Development'
                  end
                end
                def test_new_should_only_show_active_time_entry_activities
                  @request.session[:user_id] = 3
                  get :new, :project_id => 1
                  assert_response :success
                  assert_select 'option', :text => 'Inactive Activity', :count => 0
                end
                def test_get_edit_existing_time
                  @request.session[:user_id] = 2
                  get :edit, :id => 2, :project_id => nil
                  assert_response :success
                  assert_template 'edit'
                  assert_select 'form[action=?]', '/time_entries/2'
                end
                def test_get_edit_with_an_existing_time_entry_with_inactive_activity
                  te = TimeEntry.find(1)
                  te.activity = TimeEntryActivity.find_by_name("Inactive Activity")
                  te.save!
                  @request.session[:user_id] = 1
                  get :edit, :project_id => 1, :id => 1
                  assert_response :success
                  assert_template 'edit'
                  # Blank option since nothing is pre-selected
                  assert_select 'option', :text => '--- Please select ---'
                end
                def test_post_create
                  @request.session[:user_id] = 3
                  assert_difference 'TimeEntry.count' do
                    post :create, :project_id => 1,
                              :time_entry => {:comments => 'Some work on TimelogControllerTest',
                                              # Not the default activity
                                              :activity_id => '11',
                                              :spent_on => '2008-03-14',
                                              :issue_id => '1',
                                              :hours => '7.3'}
                    assert_redirected_to '/projects/ecookbook/time_entries'
                  end
                  t = TimeEntry.order('id DESC').first
                  assert_not_nil t
                  assert_equal 'Some work on TimelogControllerTest', t.comments
                  assert_equal 1, t.project_id
                  assert_equal 1, t.issue_id
                  assert_equal 11, t.activity_id
                  assert_equal 7.3, t.hours
                  assert_equal 3, t.user_id
                end
                def test_post_create_with_blank_issue
                  @request.session[:user_id] = 3
                  assert_difference 'TimeEntry.count' do
                    post :create, :project_id => 1,
                              :time_entry => {:comments => 'Some work on TimelogControllerTest',
                                              # Not the default activity
                                              :activity_id => '11',
                                              :issue_id => '',
                                              :spent_on => '2008-03-14',
                                              :hours => '7.3'}
                    assert_redirected_to '/projects/ecookbook/time_entries'
                  end
                  t = TimeEntry.order('id DESC').first
                  assert_not_nil t
                  assert_equal 'Some work on TimelogControllerTest', t.comments
                  assert_equal 1, t.project_id
                  assert_nil t.issue_id
                  assert_equal 11, t.activity_id
                  assert_equal 7.3, t.hours
                  assert_equal 3, t.user_id
                end
                def test_create_and_continue_at_project_level
                  @request.session[:user_id] = 2
                  assert_difference 'TimeEntry.count' do
                    post :create, :time_entry => {:project_id => '1',
                                                  :activity_id => '11',
                                                  :issue_id => '',
                                                  :spent_on => '2008-03-14',
                                                  :hours => '7.3'},
                                  :continue => '1'
                    assert_redirected_to '/time_entries/new?time_entry%5Bactivity_id%5D=11&time_entry%5Bissue_id%5D=&time_entry%5Bproject_id%5D=1'
                  end
                end
                def test_create_and_continue_at_issue_level
                  @request.session[:user_id] = 2
                  assert_difference 'TimeEntry.count' do
                    post :create, :time_entry => {:project_id => '',
                                                  :activity_id => '11',
                                                  :issue_id => '1',
                                                  :spent_on => '2008-03-14',
                                                  :hours => '7.3'},
                                  :continue => '1'
                    assert_redirected_to '/time_entries/new?time_entry%5Bactivity_id%5D=11&time_entry%5Bissue_id%5D=1&time_entry%5Bproject_id%5D='
                  end
                end
                def test_create_and_continue_with_project_id
                  @request.session[:user_id] = 2
                  assert_difference 'TimeEntry.count' do
                    post :create, :project_id => 1,
                                  :time_entry => {:activity_id => '11',
                                                  :issue_id => '',
                                                  :spent_on => '2008-03-14',
                                                  :hours => '7.3'},
                                  :continue => '1'
                    assert_redirected_to '/projects/ecookbook/time_entries/new?time_entry%5Bactivity_id%5D=11&time_entry%5Bissue_id%5D=&time_entry%5Bproject_id%5D='
                  end
                end
                def test_create_and_continue_with_issue_id
                  @request.session[:user_id] = 2
                  assert_difference 'TimeEntry.count' do
                    post :create, :issue_id => 1,
                                  :time_entry => {:activity_id => '11',
                                                  :issue_id => '1',
                                                  :spent_on => '2008-03-14',
                                                  :hours => '7.3'},
                                  :continue => '1'
                    assert_redirected_to '/issues/1/time_entries/new?time_entry%5Bactivity_id%5D=11&time_entry%5Bissue_id%5D=1&time_entry%5Bproject_id%5D='
                  end
                end
                def test_create_without_log_time_permission_should_be_denied
                  @request.session[:user_id] = 2
                  Role.find_by_name('Manager').remove_permission! :log_time
                  post :create, :project_id => 1,
                              :time_entry => {:activity_id => '11',
                                              :issue_id => '',
                                              :spent_on => '2008-03-14',
                                              :hours => '7.3'}
                  assert_response 403
                end
                def test_create_without_project_and_issue_should_fail
                  @request.session[:user_id] = 2
                  post :create, :time_entry => {:issue_id => ''}
                  assert_response :success
                  assert_template 'new'
                end
                def test_create_with_failure
                  @request.session[:user_id] = 2
                  post :create, :project_id => 1,
                              :time_entry => {:activity_id => '',
                                              :issue_id => '',
                                              :spent_on => '2008-03-14',
                                              :hours => '7.3'}
                  assert_response :success
                  assert_template 'new'
                end
                def test_create_without_project
                  @request.session[:user_id] = 2
                  assert_difference 'TimeEntry.count' do
                    post :create, :time_entry => {:project_id => '1',
                                                :activity_id => '11',
                                                :issue_id => '',
                                                :spent_on => '2008-03-14',
                                                :hours => '7.3'}
                  end
                  assert_redirected_to '/projects/ecookbook/time_entries'
                  time_entry = TimeEntry.order('id DESC').first
                  assert_equal 1, time_entry.project_id
                end
                def test_create_without_project_should_fail_with_issue_not_inside_project
                  @request.session[:user_id] = 2
                  assert_no_difference 'TimeEntry.count' do
                    post :create, :time_entry => {:project_id => '1',
                                                :activity_id => '11',
                                                :issue_id => '5',
                                                :spent_on => '2008-03-14',
                                                :hours => '7.3'}
                  end
                  assert_response :success
                  assert assigns(:time_entry).errors[:issue_id].present?
                end
                def test_create_without_project_should_deny_without_permission
                  @request.session[:user_id] = 2
                  Project.find(3).disable_module!(:time_tracking)
                  assert_no_difference 'TimeEntry.count' do
                    post :create, :time_entry => {:project_id => '3',
                                                :activity_id => '11',
                                                :issue_id => '',
                                                :spent_on => '2008-03-14',
                                                :hours => '7.3'}
                  end
                  assert_response 403
                end
                def test_create_without_project_with_failure
                  @request.session[:user_id] = 2
                  assert_no_difference 'TimeEntry.count' do
                    post :create, :time_entry => {:project_id => '1',
                                                :activity_id => '11',
                                                :issue_id => '',
                                                :spent_on => '2008-03-14',
                                                :hours => ''}
                  end
                  assert_response :success
                  assert_select 'select[name=?]', 'time_entry[project_id]' do
                    assert_select 'option[value="1"][selected=selected]'
                  end
                end
                def test_update
                  entry = TimeEntry.find(1)
                  assert_equal 1, entry.issue_id
                  assert_equal 2, entry.user_id
                  @request.session[:user_id] = 1
                  put :update, :id => 1,
                              :time_entry => {:issue_id => '2',
                                              :hours => '8'}
                  assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                  entry.reload
                  assert_equal 8, entry.hours
                  assert_equal 2, entry.issue_id
                  assert_equal 2, entry.user_id
                end
                def test_update_should_allow_to_change_issue_to_another_project
                  entry = TimeEntry.generate!(:issue_id => 1)
                  @request.session[:user_id] = 1
                  put :update, :id => entry.id, :time_entry => {:issue_id => '5'}
                  assert_response 302
                  entry.reload
                  assert_equal 5, entry.issue_id
                  assert_equal 3, entry.project_id
                end
                def test_update_should_not_allow_to_change_issue_to_an_invalid_project
                  entry = TimeEntry.generate!(:issue_id => 1)
                  Project.find(3).disable_module!(:time_tracking)
                  @request.session[:user_id] = 1
                  put :update, :id => entry.id, :time_entry => {:issue_id => '5'}
                  assert_response 200
                  assert_include "Issue is invalid", assigns(:time_entry).errors.full_messages
                end
                def test_get_bulk_edit
                  @request.session[:user_id] = 2
                  get :bulk_edit, :ids => [1, 2]
                  assert_response :success
                  assert_template 'bulk_edit'
                  assert_select 'ul#bulk-selection' do
                    assert_select 'li', 2
                    assert_select 'li a', :text => '03/23/2007 - eCookbook: 4.25 hours'
                  end
                  assert_select 'form#bulk_edit_form[action=?]', '/time_entries/bulk_update' do
                    # System wide custom field
                    assert_select 'select[name=?]', 'time_entry[custom_field_values][10]'
                    # Activities
                    assert_select 'select[name=?]', 'time_entry[activity_id]' do
                      assert_select 'option[value=""]', :text => '(No change)'
                      assert_select 'option[value="9"]', :text => 'Design'
                    end
                  end
                end
                def test_get_bulk_edit_on_different_projects
                  @request.session[:user_id] = 2
                  get :bulk_edit, :ids => [1, 2, 6]
                  assert_response :success
                  assert_template 'bulk_edit'
                end
                def test_bulk_update
                  @request.session[:user_id] = 2
                  # update time entry activity
                  post :bulk_update, :ids => [1, 2], :time_entry => { :activity_id => 9}
                  assert_response 302
                  # check that the issues were updated
                  assert_equal [9, 9], TimeEntry.where(:id => [1, 2]).collect {|i| i.activity_id}
                end
                def test_bulk_update_with_failure
                  @request.session[:user_id] = 2
                  post :bulk_update, :ids => [1, 2], :time_entry => { :hours => 'A'}
                  assert_response 302
                  assert_match /Failed to save 2 time entrie/, flash[:error]
                end
                def test_bulk_update_on_different_projects
                  @request.session[:user_id] = 2
                  # makes user a manager on the other project
                  Member.create!(:user_id => 2, :project_id => 3, :role_ids => [1])
                  # update time entry activity
                  post :bulk_update, :ids => [1, 2, 4], :time_entry => { :activity_id => 9 }
                  assert_response 302
                  # check that the issues were updated
                  assert_equal [9, 9, 9], TimeEntry.where(:id => [1, 2, 4]).collect {|i| i.activity_id}
                end
                def test_bulk_update_on_different_projects_without_rights
                  @request.session[:user_id] = 3
                  user = User.find(3)
                  action = { :controller => "timelog", :action => "bulk_update" }
                  assert user.allowed_to?(action, TimeEntry.find(1).project)
                  assert ! user.allowed_to?(action, TimeEntry.find(5).project)
                  post :bulk_update, :ids => [1, 5], :time_entry => { :activity_id => 9 }
                  assert_response 403
                end
                def test_bulk_update_custom_field
                  @request.session[:user_id] = 2
                  post :bulk_update, :ids => [1, 2], :time_entry => { :custom_field_values => {'10' => '0'} }
                  assert_response 302
                  assert_equal ["0", "0"], TimeEntry.where(:id => [1, 2]).collect {|i| i.custom_value_for(10).value}
                end
                def test_post_bulk_update_should_redirect_back_using_the_back_url_parameter
                  @request.session[:user_id] = 2
                  post :bulk_update, :ids => [1,2], :back_url => '/time_entries'
                  assert_response :redirect
                  assert_redirected_to '/time_entries'
                end
                def test_post_bulk_update_should_not_redirect_back_using_the_back_url_parameter_off_the_host
                  @request.session[:user_id] = 2
                  post :bulk_update, :ids => [1,2], :back_url => 'http://google.com'
                  assert_response :redirect
                  assert_redirected_to :controller => 'timelog', :action => 'index', :project_id => Project.find(1).identifier
                end
                def test_post_bulk_update_without_edit_permission_should_be_denied
                  @request.session[:user_id] = 2
                  Role.find_by_name('Manager').remove_permission! :edit_time_entries
                  post :bulk_update, :ids => [1,2]
                  assert_response 403
                end
                def test_destroy
                  @request.session[:user_id] = 2
                  delete :destroy, :id => 1
                  assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                  assert_equal I18n.t(:notice_successful_delete), flash[:notice]
                  assert_nil TimeEntry.find_by_id(1)
                end
                def test_destroy_should_fail
                  # simulate that this fails (e.g. due to a plugin), see #5700
                  TimeEntry.any_instance.expects(:destroy).returns(false)
                  @request.session[:user_id] = 2
                  delete :destroy, :id => 1
                  assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                  assert_equal I18n.t(:notice_unable_delete_time_entry), flash[:error]
                  assert_not_nil TimeEntry.find_by_id(1)
                end
                def test_index_all_projects
                  get :index
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:total_hours)
                  assert_equal "162.90", "%.2f" % assigns(:total_hours)
                  assert_select 'form#query_form[action=?]', '/time_entries'
                end
                def test_index_all_projects_should_show_log_time_link
                  @request.session[:user_id] = 2
                  get :index
                  assert_response :success
                  assert_template 'index'
                  assert_select 'a[href=?]', '/time_entries/new', :text => /Log time/
                end
                def test_index_my_spent_time
                  @request.session[:user_id] = 2
                  get :index, :user_id => 'me'
                  assert_response :success
                  assert_template 'index'
                  assert assigns(:entries).all? {|entry| entry.user_id == 2}
                end
                def test_index_at_project_level
                  get :index, :project_id => 'ecookbook'
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:entries)
                  assert_equal 4, assigns(:entries).size
                  # project and subproject
                  assert_equal [1, 3], assigns(:entries).collect(&:project_id).uniq.sort
                  assert_not_nil assigns(:total_hours)
                  assert_equal "162.90", "%.2f" % assigns(:total_hours)
                  assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries'
                end
                def test_index_with_display_subprojects_issues_to_false_should_not_include_subproject_entries
                  entry = TimeEntry.generate!(:project => Project.find(3))
                  with_settings :display_subprojects_issues => '0' do
                    get :index, :project_id => 'ecookbook'
                    assert_response :success
                    assert_template 'index'
                    assert_not_include entry, assigns(:entries)
                  end
                end
                def test_index_with_display_subprojects_issues_to_false_and_subproject_filter_should_include_subproject_entries
                  entry = TimeEntry.generate!(:project => Project.find(3))
                  with_settings :display_subprojects_issues => '0' do
                    get :index, :project_id => 'ecookbook', :subproject_id => 3
                    assert_response :success
                    assert_template 'index'
                    assert_include entry, assigns(:entries)
                  end
                end
                def test_index_at_project_level_with_date_range
                  get :index, :project_id => 'ecookbook',
                    :f => ['spent_on'],
                    :op => {'spent_on' => '><'},
                    :v => {'spent_on' => ['2007-03-20', '2007-04-30']}
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:entries)
                  assert_equal 3, assigns(:entries).size
                  assert_not_nil assigns(:total_hours)
                  assert_equal "12.90", "%.2f" % assigns(:total_hours)
                  assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries'
                end
                def test_index_at_project_level_with_date_range_using_from_and_to_params
                  get :index, :project_id => 'ecookbook', :from => '2007-03-20', :to => '2007-04-30'
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:entries)
                  assert_equal 3, assigns(:entries).size
                  assert_not_nil assigns(:total_hours)
                  assert_equal "12.90", "%.2f" % assigns(:total_hours)
                  assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries'
                end
                def test_index_at_project_level_with_period
                  get :index, :project_id => 'ecookbook',
                    :f => ['spent_on'],
                    :op => {'spent_on' => '>t-'},
                    :v => {'spent_on' => ['7']}
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:entries)
                  assert_not_nil assigns(:total_hours)
                  assert_select 'form#query_form[action=?]', '/projects/ecookbook/time_entries'
                end
                def test_index_at_issue_level
                  get :index, :issue_id => 1
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:entries)
                  assert_equal 2, assigns(:entries).size
                  assert_not_nil assigns(:total_hours)
                  assert_equal 154.25, assigns(:total_hours)
                  # display all time
                  assert_nil assigns(:from)
                  assert_nil assigns(:to)
                  assert_select 'form#query_form[action=?]', '/issues/1/time_entries'
                end
                def test_index_should_sort_by_spent_on_and_created_on
                  t1 = TimeEntry.create!(:user => User.find(1), :project => Project.find(1), :hours => 1, :spent_on => '2012-06-16', :created_on => '2012-06-16 20:00:00', :activity_id => 10)
                  t2 = TimeEntry.create!(:user => User.find(1), :project => Project.find(1), :hours => 1, :spent_on => '2012-06-16', :created_on => '2012-06-16 20:05:00', :activity_id => 10)
                  t3 = TimeEntry.create!(:user => User.find(1), :project => Project.find(1), :hours => 1, :spent_on => '2012-06-15', :created_on => '2012-06-16 20:10:00', :activity_id => 10)
                  get :index, :project_id => 1,
                    :f => ['spent_on'],
                    :op => {'spent_on' => '><'},
                    :v => {'spent_on' => ['2012-06-15', '2012-06-16']}
                  assert_response :success
                  assert_equal [t2, t1, t3], assigns(:entries)
                  get :index, :project_id => 1,
                    :f => ['spent_on'],
                    :op => {'spent_on' => '><'},
                    :v => {'spent_on' => ['2012-06-15', '2012-06-16']},
                    :sort => 'spent_on'
                  assert_response :success
                  assert_equal [t3, t1, t2], assigns(:entries)
                end
                def test_index_with_filter_on_issue_custom_field
                  issue = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {2 => 'filter_on_issue_custom_field'})
                  entry = TimeEntry.generate!(:issue => issue, :hours => 2.5)
                  get :index, :f => ['issue.cf_2'], :op => {'issue.cf_2' => '='}, :v => {'issue.cf_2' => ['filter_on_issue_custom_field']}
                  assert_response :success
                  assert_equal [entry], assigns(:entries)
                end
                def test_index_with_issue_custom_field_column
                  issue = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {2 => 'filter_on_issue_custom_field'})
                  entry = TimeEntry.generate!(:issue => issue, :hours => 2.5)
                  get :index, :c => %w(project spent_on issue comments hours issue.cf_2)
                  assert_response :success
                  assert_include :'issue.cf_2', assigns(:query).column_names
                  assert_select 'td.issue_cf_2', :text => 'filter_on_issue_custom_field'
                end
                def test_index_with_time_entry_custom_field_column
                  field = TimeEntryCustomField.generate!(:field_format => 'string')
                  entry = TimeEntry.generate!(:hours => 2.5, :custom_field_values => {field.id => 'CF Value'})
                  field_name = "cf_#{field.id}"
                  get :index, :c => ["hours", field_name]
                  assert_response :success
                  assert_include field_name.to_sym, assigns(:query).column_names
                  assert_select "td.#{field_name}", :text => 'CF Value'
                end
                def test_index_with_time_entry_custom_field_sorting
                  field = TimeEntryCustomField.generate!(:field_format => 'string', :name => 'String Field')
                  TimeEntry.generate!(:hours => 2.5, :custom_field_values => {field.id => 'CF Value 1'})
                  TimeEntry.generate!(:hours => 2.5, :custom_field_values => {field.id => 'CF Value 3'})
                  TimeEntry.generate!(:hours => 2.5, :custom_field_values => {field.id => 'CF Value 2'})
                  field_name = "cf_#{field.id}"
                  get :index, :c => ["hours", field_name], :sort => field_name
                  assert_response :success
                  assert_include field_name.to_sym, assigns(:query).column_names
                  assert_select "th a.sort", :text => 'String Field'
                  # Make sure that values are properly sorted
                  values = assigns(:entries).map {|e| e.custom_field_value(field)}.compact
                  assert_equal 3, values.size
                  assert_equal values.sort, values
                end
                def test_index_atom_feed
                  get :index, :project_id => 1, :format => 'atom'
                  assert_response :success
                  assert_equal 'application/atom+xml', @response.content_type
                  assert_not_nil assigns(:items)
                  assert assigns(:items).first.is_a?(TimeEntry)
                end
                def test_index_at_project_level_should_include_csv_export_dialog
                  get :index, :project_id => 'ecookbook',
                    :f => ['spent_on'],
                    :op => {'spent_on' => '>='},
                    :v => {'spent_on' => ['2007-04-01']},
                    :c => ['spent_on', 'user']
                  assert_response :success
                  assert_select '#csv-export-options' do
                    assert_select 'form[action=?][method=get]', '/projects/ecookbook/time_entries.csv' do
                      # filter
                      assert_select 'input[name=?][value=?]', 'f[]', 'spent_on'
-                     assert_select 'input[name=?][value=?]', 'op[spent_on]', '&gt;='
+                     assert_select 'input[name=?][value=?]', 'op[spent_on]', '>='
                      assert_select 'input[name=?][value=?]', 'v[spent_on][]', '2007-04-01'
                      # columns
                      assert_select 'input[name=?][value=?]', 'c[]', 'spent_on'
                      assert_select 'input[name=?][value=?]', 'c[]', 'user'
                      assert_select 'input[name=?]', 'c[]', 2
                    end
                  end
                end
                def test_index_cross_project_should_include_csv_export_dialog
                  get :index
                  assert_response :success
                  assert_select '#csv-export-options' do
                    assert_select 'form[action=?][method=get]', '/time_entries.csv'
                  end
                end
                def test_index_at_issue_level_should_include_csv_export_dialog
                  get :index, :issue_id => 3
                  assert_response :success
                  assert_select '#csv-export-options' do
                    assert_select 'form[action=?][method=get]', '/issues/3/time_entries.csv'
                  end
                end
                def test_index_csv_all_projects
                  with_settings :date_format => '%m/%d/%Y' do
                    get :index, :format => 'csv'
                    assert_response :success
                    assert_equal 'text/csv; header=present', response.content_type
                  end
                end
                def test_index_csv
                  with_settings :date_format => '%m/%d/%Y' do
                    get :index, :project_id => 1, :format => 'csv'
                    assert_response :success
                    assert_equal 'text/csv; header=present', response.content_type
                  end
                end
                def test_index_csv_should_fill_issue_column_with_tracker_id_and_subject
                  issue = Issue.find(1)
                  entry = TimeEntry.generate!(:issue => issue, :comments => "Issue column content test")
                  get :index, :format => 'csv'
                  line = response.body.split("\n").detect {|l| l.include?(entry.comments)}
                  assert_not_nil line
                  assert_include "#{issue.tracker} #1: #{issue.subject}", line
                end
              end

test/functional/welcome_controller_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 WelcomeControllerTest < ActionController::TestCase
                fixtures :projects, :news, :users, :members
                def setup
                  User.current = nil
                end
                def test_index
                  get :index
                  assert_response :success
                  assert_template 'index'
                  assert_not_nil assigns(:news)
                  assert_not_nil assigns(:projects)
                  assert !assigns(:projects).include?(Project.where(:is_public => false).first)
                end
                def test_browser_language
                  Setting.default_language = 'en'
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  get :index
                  assert_equal :fr, @controller.current_language
                end
                def test_browser_language_alternate
                  Setting.default_language = 'en'
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'zh-TW'
                  get :index
                  assert_equal :"zh-TW", @controller.current_language
                end
                def test_browser_language_alternate_not_valid
                  Setting.default_language = 'en'
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr-CA'
                  get :index
                  assert_equal :fr, @controller.current_language
                end
                def test_browser_language_should_be_ignored_with_force_default_language_for_anonymous
                  Setting.default_language = 'en'
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  with_settings :force_default_language_for_anonymous => '1' do
                    get :index
                    assert_equal :en, @controller.current_language
                  end
                end
                def test_user_language_should_be_used
                  Setting.default_language = 'fi'
                  user = User.find(2).update_attribute :language, 'it'
                  @request.session[:user_id] = 2
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  get :index
                  assert_equal :it, @controller.current_language
                end
                def test_user_language_should_be_ignored_if_force_default_language_for_loggedin
                  Setting.default_language = 'fi'
                  user = User.find(2).update_attribute :language, 'it'
                  @request.session[:user_id] = 2
                  @request.env['HTTP_ACCEPT_LANGUAGE'] = 'fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3'
                  with_settings :force_default_language_for_loggedin => '1' do
                    get :index
                    assert_equal :fi, @controller.current_language
                  end
                end
                def test_robots
                  get :robots
                  assert_response :success
                  assert_equal 'text/plain', @response.content_type
                  assert @response.body.match(%r{^Disallow: /projects/ecookbook/issues\r?$})
                end
                def test_warn_on_leaving_unsaved_turn_on
                  user = User.find(2)
                  user.pref.warn_on_leaving_unsaved = '1'
                  user.pref.save!
                  @request.session[:user_id] = 2
                  get :index
                  assert_select 'script', :text => %r{warnLeavingUnsaved}
                end
                def test_warn_on_leaving_unsaved_turn_off
                  user = User.find(2)
                  user.pref.warn_on_leaving_unsaved = '0'
                  user.pref.save!
                  @request.session[:user_id] = 2
                  get :index
                  assert_select 'script', :text => %r{warnLeavingUnsaved}, :count => 0
                end
                def test_logout_link_should_post
                  @request.session[:user_id] = 2
                  get :index
                  assert_select 'a[href="/logout"][data-method=post]', :text => 'Sign out'
                end
                def test_call_hook_mixed_in
                  assert @controller.respond_to?(:call_hook)
                end
                def test_project_jump_box_should_escape_names_once
                  Project.find(1).update_attribute :name, 'Foo & Bar'
                  @request.session[:user_id] = 2
                  get :index
                  assert_select "#header select" do
-                   assert_select "option", :text => 'Foo &amp; Bar'
+                   assert_select "option", :text => 'Foo & Bar'
                  end
                end
                def test_api_offset_and_limit_without_params
                  assert_equal [0, 25], @controller.api_offset_and_limit({})
                end
                def test_api_offset_and_limit_with_limit
                  assert_equal [0, 30], @controller.api_offset_and_limit({:limit => 30})
                  assert_equal [0, 100], @controller.api_offset_and_limit({:limit => 120})
                  assert_equal [0, 25], @controller.api_offset_and_limit({:limit => -10})
                end
                def test_api_offset_and_limit_with_offset
                  assert_equal [10, 25], @controller.api_offset_and_limit({:offset => 10})
                  assert_equal [0, 25], @controller.api_offset_and_limit({:offset => -10})
                end
                def test_api_offset_and_limit_with_offset_and_limit
                  assert_equal [10, 50], @controller.api_offset_and_limit({:offset => 10, :limit => 50})
                end
                def test_api_offset_and_limit_with_page
                  assert_equal [0, 25], @controller.api_offset_and_limit({:page => 1})
                  assert_equal [50, 25], @controller.api_offset_and_limit({:page => 3})
                  assert_equal [0, 25], @controller.api_offset_and_limit({:page => 0})
                  assert_equal [0, 25], @controller.api_offset_and_limit({:page => -2})
                end
                def test_api_offset_and_limit_with_page_and_limit
                  assert_equal [0, 100], @controller.api_offset_and_limit({:page => 1, :limit => 100})
                  assert_equal [200, 100], @controller.api_offset_and_limit({:page => 3, :limit => 100})
                end
                def test_unhautorized_exception_with_anonymous_should_redirect_to_login
                  WelcomeController.any_instance.stubs(:index).raises(::Unauthorized)
                  get :index
                  assert_response 302
                  assert_redirected_to('/login?back_url='+CGI.escape('http://test.host/'))
                end
                def test_unhautorized_exception_with_anonymous_and_xmlhttprequest_should_respond_with_401_to_anonymous
                  WelcomeController.any_instance.stubs(:index).raises(::Unauthorized)
                  @request.env["HTTP_X_REQUESTED_WITH"] = "XMLHttpRequest"
                  get :index
                  assert_response 401
                end
              end

test/functional/workflows_controller_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 WorkflowsControllerTest < ActionController::TestCase
                fixtures :roles, :trackers, :workflows, :users, :issue_statuses
                def setup
                  User.current = nil
                  @request.session[:user_id] = 1 # admin
                end
                def test_index
                  get :index
                  assert_response :success
                  assert_template 'index'
                  count = WorkflowTransition.where(:role_id => 1, :tracker_id => 2).count
-                 assert_select 'a[href=?]', '/workflows/edit?role_id=1&amp;tracker_id=2', :content => count.to_s
+                 assert_select 'a[href=?]', '/workflows/edit?role_id=1&tracker_id=2', :content => count.to_s
                end
                def test_get_edit
                  get :edit
                  assert_response :success
                  assert_template 'edit'
                end
                def test_get_edit_with_role_and_tracker
                  WorkflowTransition.delete_all
                  WorkflowTransition.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 2, :new_status_id => 3)
                  WorkflowTransition.create!(:role_id => 2, :tracker_id => 1, :old_status_id => 3, :new_status_id => 5)
                  get :edit, :role_id => 2, :tracker_id => 1
                  assert_response :success
                  assert_template 'edit'
                  # used status only
                  assert_not_nil assigns(:statuses)
                  assert_equal [2, 3, 5], assigns(:statuses).collect(&:id)
                  # allowed transitions
                  assert_select 'input[type=checkbox][name=?][value="1"][checked=checked]', 'transitions[3][5][always]'
                  # not allowed
                  assert_select 'input[type=checkbox][name=?][value="1"]:not([checked=checked])', 'transitions[3][2][always]'
                  # unused
                  assert_select 'input[type=checkbox][name=?]', 'transitions[1][1][always]', 0
                end
                def test_get_edit_with_all_roles_and_all_trackers
                  get :edit, :role_id => 'all', :tracker_id => 'all'
                  assert_response :success
                  assert_equal Role.sorted.to_a, assigns(:roles)
                  assert_equal Tracker.sorted.to_a, assigns(:trackers)
                end
                def test_get_edit_with_role_and_tracker_and_all_statuses
                  WorkflowTransition.delete_all
                  get :edit, :role_id => 2, :tracker_id => 1, :used_statuses_only => '0'
                  assert_response :success
                  assert_template 'edit'
                  assert_not_nil assigns(:statuses)
                  assert_equal IssueStatus.count, assigns(:statuses).size
                  assert_select 'input[type=checkbox][name=?]', 'transitions[1][1][always]'
                end
                def test_post_edit
                  WorkflowTransition.delete_all
                  post :edit, :role_id => 2, :tracker_id => 1,
                    :transitions => {
                      '4' => {'5' => {'always' => '1'}},
                      '3' => {'1' => {'always' => '1'}, '2' => {'always' => '1'}}
                    }
                  assert_response 302
                  assert_equal 3, WorkflowTransition.where(:tracker_id => 1, :role_id => 2).count
                  assert_not_nil  WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 3, :new_status_id => 2).first
                  assert_nil      WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 5, :new_status_id => 4).first
                end
                def test_post_edit_with_additional_transitions
                  WorkflowTransition.delete_all
                  post :edit, :role_id => 2, :tracker_id => 1,
                    :transitions => {
                      '4' => {'5' => {'always' => '1', 'author' => '0', 'assignee' => '0'}},
                      '3' => {'1' => {'always' => '0', 'author' => '1', 'assignee' => '0'},
                              '2' => {'always' => '0', 'author' => '0', 'assignee' => '1'},
                              '4' => {'always' => '0', 'author' => '1', 'assignee' => '1'}}
                    }
                  assert_response 302
                  assert_equal 4, WorkflowTransition.where(:tracker_id => 1, :role_id => 2).count
                  w = WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 4, :new_status_id => 5).first
                  assert ! w.author
                  assert ! w.assignee
                  w = WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 3, :new_status_id => 1).first
                  assert w.author
                  assert ! w.assignee
                  w = WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 3, :new_status_id => 2).first
                  assert ! w.author
                  assert w.assignee
                  w = WorkflowTransition.where(:role_id => 2, :tracker_id => 1, :old_status_id => 3, :new_status_id => 4).first
                  assert w.author
                  assert w.assignee
                end
                def test_get_permissions
                  get :permissions
                  assert_response :success
                  assert_template 'permissions'
                end
                def test_get_permissions_with_role_and_tracker
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 2, :field_name => 'assigned_to_id', :rule => 'required')
                  WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 2, :field_name => 'fixed_version_id', :rule => 'required')
                  WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 3, :field_name => 'fixed_version_id', :rule => 'readonly')
                  get :permissions, :role_id => 1, :tracker_id => 2
                  assert_response :success
                  assert_template 'permissions'
                  assert_select 'input[name=?][value="1"]', 'role_id[]'
                  assert_select 'input[name=?][value="2"]', 'tracker_id[]'
                  # Required field
                  assert_select 'select[name=?]', 'permissions[2][assigned_to_id]' do
                    assert_select 'option[value=""]'
                    assert_select 'option[value=""][selected=selected]', 0
                    assert_select 'option[value=readonly]', :text => 'Read-only'
                    assert_select 'option[value=readonly][selected=selected]', 0
                    assert_select 'option[value=required]', :text => 'Required'
                    assert_select 'option[value=required][selected=selected]'
                  end
                  # Read-only field
                  assert_select 'select[name=?]', 'permissions[3][fixed_version_id]' do
                    assert_select 'option[value=""]'
                    assert_select 'option[value=""][selected=selected]', 0
                    assert_select 'option[value=readonly]', :text => 'Read-only'
                    assert_select 'option[value=readonly][selected=selected]'
                    assert_select 'option[value=required]', :text => 'Required'
                    assert_select 'option[value=required][selected=selected]', 0
                  end
                  # Other field
                  assert_select 'select[name=?]', 'permissions[3][due_date]' do
                    assert_select 'option[value=""]'
                    assert_select 'option[value=""][selected=selected]', 0
                    assert_select 'option[value=readonly]', :text => 'Read-only'
                    assert_select 'option[value=readonly][selected=selected]', 0
                    assert_select 'option[value=required]', :text => 'Required'
                    assert_select 'option[value=required][selected=selected]', 0
                  end
                end
                def test_get_permissions_with_required_custom_field_should_not_show_required_option
                  cf = IssueCustomField.create!(:name => 'Foo', :field_format => 'string', :tracker_ids => [1], :is_required => true)
                  get :permissions, :role_id => 1, :tracker_id => 1
                  assert_response :success
                  assert_template 'permissions'
                  # Custom field that is always required
                  # The default option is "(Required)"
                  assert_select 'select[name=?]', "permissions[3][#{cf.id}]" do
                    assert_select 'option[value=""]'
                    assert_select 'option[value=readonly]', :text => 'Read-only'
                    assert_select 'option[value=required]', 0
                  end
                end
                def test_get_permissions_should_disable_hidden_custom_fields
                  cf1 = IssueCustomField.generate!(:tracker_ids => [1], :visible => true)
                  cf2 = IssueCustomField.generate!(:tracker_ids => [1], :visible => false, :role_ids => [1])
                  cf3 = IssueCustomField.generate!(:tracker_ids => [1], :visible => false, :role_ids => [1, 2])
                  get :permissions, :role_id => 2, :tracker_id => 1
                  assert_response :success
                  assert_template 'permissions'
                  assert_select 'select[name=?]:not(.disabled)', "permissions[1][#{cf1.id}]"
                  assert_select 'select[name=?]:not(.disabled)', "permissions[1][#{cf3.id}]"
                  assert_select 'select[name=?][disabled=disabled]', "permissions[1][#{cf2.id}]" do
                    assert_select 'option[value=""][selected=selected]', :text => 'Hidden'
                  end
                end
                def test_get_permissions_with_missing_permissions_for_roles_should_default_to_no_change
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 1, :field_name => 'assigned_to_id', :rule => 'required')
                  get :permissions, :role_id => [1, 2], :tracker_id => 2
                  assert_response :success
                  assert_select 'select[name=?]', 'permissions[1][assigned_to_id]' do
                    assert_select 'option[selected]', 1
                    assert_select 'option[selected][value=no_change]'
                  end
                end
                def test_get_permissions_with_different_permissions_for_roles_should_default_to_no_change
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 1, :field_name => 'assigned_to_id', :rule => 'required')
                  WorkflowPermission.create!(:role_id => 2, :tracker_id => 2, :old_status_id => 1, :field_name => 'assigned_to_id', :rule => 'readonly')
                  get :permissions, :role_id => [1, 2], :tracker_id => 2
                  assert_response :success
                  assert_select 'select[name=?]', 'permissions[1][assigned_to_id]' do
                    assert_select 'option[selected]', 1
                    assert_select 'option[selected][value=no_change]'
                  end
                end
                def test_get_permissions_with_same_permissions_for_roles_should_default_to_permission
                  WorkflowPermission.delete_all
                  WorkflowPermission.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 1, :field_name => 'assigned_to_id', :rule => 'required')
                  WorkflowPermission.create!(:role_id => 2, :tracker_id => 2, :old_status_id => 1, :field_name => 'assigned_to_id', :rule => 'required')
                  get :permissions, :role_id => [1, 2], :tracker_id => 2
                  assert_response :success
                  assert_select 'select[name=?]', 'permissions[1][assigned_to_id]' do
                    assert_select 'option[selected]', 1
                    assert_select 'option[selected][value=required]'
                  end
                end
                def test_get_permissions_with_role_and_tracker_and_all_statuses_should_show_all_statuses
                  WorkflowTransition.delete_all
                  get :permissions, :role_id => 1, :tracker_id => 2, :used_statuses_only => '0'
                  assert_response :success
                  assert_equal IssueStatus.sorted.to_a, assigns(:statuses)
                end
                def test_post_permissions
                  WorkflowPermission.delete_all
                  post :permissions, :role_id => 1, :tracker_id => 2, :permissions => {
                    '1' => {'assigned_to_id' => '', 'fixed_version_id' => 'required', 'due_date' => ''},
                    '2' => {'assigned_to_id' => 'readonly', 'fixed_version_id' => 'readonly', 'due_date' => ''},
                    '3' => {'assigned_to_id' => '',  'fixed_version_id' => '', 'due_date' => ''}
                  }
                  assert_response 302
                  workflows = WorkflowPermission.all
                  assert_equal 3, workflows.size
                  workflows.each do |workflow|
                    assert_equal 1, workflow.role_id
                    assert_equal 2, workflow.tracker_id
                  end
                  assert workflows.detect {|wf| wf.old_status_id == 2 && wf.field_name == 'assigned_to_id' && wf.rule == 'readonly'}
                  assert workflows.detect {|wf| wf.old_status_id == 1 && wf.field_name == 'fixed_version_id' && wf.rule == 'required'}
                  assert workflows.detect {|wf| wf.old_status_id == 2 && wf.field_name == 'fixed_version_id' && wf.rule == 'readonly'}
                end
                def test_get_copy
                  get :copy
                  assert_response :success
                  assert_template 'copy'
                  assert_select 'select[name=source_tracker_id]' do
                    assert_select 'option[value="1"]', :text => 'Bug'
                  end
                  assert_select 'select[name=source_role_id]' do
                    assert_select 'option[value="2"]', :text => 'Developer'
                  end
                  assert_select 'select[name=?]', 'target_tracker_ids[]' do
                    assert_select 'option[value="3"]', :text => 'Support request'
                  end
                  assert_select 'select[name=?]', 'target_role_ids[]' do
                    assert_select 'option[value="1"]', :text => 'Manager'
                  end
                end
                def test_post_copy_one_to_one
                  source_transitions = status_transitions(:tracker_id => 1, :role_id => 2)
                  post :copy, :source_tracker_id => '1', :source_role_id => '2',
                              :target_tracker_ids => ['3'], :target_role_ids => ['1']
                  assert_response 302
                  assert_equal source_transitions, status_transitions(:tracker_id => 3, :role_id => 1)
                end
                def test_post_copy_one_to_many
                  source_transitions = status_transitions(:tracker_id => 1, :role_id => 2)
                  post :copy, :source_tracker_id => '1', :source_role_id => '2',
                              :target_tracker_ids => ['2', '3'], :target_role_ids => ['1', '3']
                  assert_response 302
                  assert_equal source_transitions, status_transitions(:tracker_id => 2, :role_id => 1)
                  assert_equal source_transitions, status_transitions(:tracker_id => 3, :role_id => 1)
                  assert_equal source_transitions, status_transitions(:tracker_id => 2, :role_id => 3)
                  assert_equal source_transitions, status_transitions(:tracker_id => 3, :role_id => 3)
                end
                def test_post_copy_many_to_many
                  source_t2 = status_transitions(:tracker_id => 2, :role_id => 2)
                  source_t3 = status_transitions(:tracker_id => 3, :role_id => 2)
                  post :copy, :source_tracker_id => 'any', :source_role_id => '2',
                              :target_tracker_ids => ['2', '3'], :target_role_ids => ['1', '3']
                  assert_response 302
                  assert_equal source_t2, status_transitions(:tracker_id => 2, :role_id => 1)
                  assert_equal source_t3, status_transitions(:tracker_id => 3, :role_id => 1)
                  assert_equal source_t2, status_transitions(:tracker_id => 2, :role_id => 3)
                  assert_equal source_t3, status_transitions(:tracker_id => 3, :role_id => 3)
                end
                def test_post_copy_with_incomplete_source_specification_should_fail
                  assert_no_difference 'WorkflowRule.count' do
                    post :copy,
                      :source_tracker_id => '', :source_role_id => '2',
                      :target_tracker_ids => ['2', '3'], :target_role_ids => ['1', '3']
                    assert_response 200
                    assert_select 'div.flash.error', :text => 'Please select a source tracker or role'
                  end
                end
                def test_post_copy_with_incomplete_target_specification_should_fail
                  assert_no_difference 'WorkflowRule.count' do
                    post :copy,
                      :source_tracker_id => '1', :source_role_id => '2',
                      :target_tracker_ids => ['2', '3']
                    assert_response 200
                    assert_select 'div.flash.error', :text => 'Please select target tracker(s) and role(s)'
                  end
                end
                # Returns an array of status transitions that can be compared
                def status_transitions(conditions)
                  WorkflowTransition.
                    where(conditions).
                    order('tracker_id, role_id, old_status_id, new_status_id').
                    collect {|w| [w.old_status, w.new_status_id]}
                end
              end

test/integration/api_test/attachments_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/api_test/groups_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/api_test/issue_statuses_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/api_test/issues_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/api_test/memberships_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/api_test/projects_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/api_test/queries_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/api_test/roles_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/api_test/trackers_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/api_test/versions_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/issues_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/layout_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/lib/redmine/themes_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/test_helper.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/ui/issues_test_ui.rb ~~test/ui/issues_test.rb~~ renamed 0 0

NO CONTENT: file renamed from test/ui/issues_test.rb to test/ui/issues_test_ui.rb

test/unit/helpers/application_helper_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/unit/helpers/groups_helper_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/unit/helpers/members_helper_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/unit/helpers/projects_helper_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/unit/lib/redmine/helpers/gantt_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/unit/lib/redmine/menu_manager/menu_helper_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/unit/mailer_test.rb 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

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