jro_apps/redmine Commit - r15849:9d747d6811ed

Reset current user before helpers tests....

Jean-Philippe Lang -

r15849:9d747d6811ed

parent child

Context file:

r15849:9d747d6811ed

Collapse all files

test/test_helper.rb +4 -1

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             if ENV["COVERAGE"]
               require 'simplecov'
               require File.expand_path(File.dirname(__FILE__) + "/coverage/html_formatter")
               SimpleCov.formatter = Redmine::Coverage::HtmlFormatter
               SimpleCov.start 'rails'
             end
             $redmine_test_ldap_server = ENV['REDMINE_TEST_LDAP_SERVER'] || '127.0.0.1'
             ENV["RAILS_ENV"] = "test"
             require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
             require 'rails/test_help'
             require Rails.root.join('test', 'mocks', 'open_id_authentication_mock.rb').to_s
             require File.expand_path(File.dirname(__FILE__) + '/object_helpers')
             include ObjectHelpers
             require 'net/ldap'
             require 'mocha/setup'
             Redmine::SudoMode.disable!
             class ActionView::TestCase
               helper :application
               include ApplicationHelper
             end
             class ActiveSupport::TestCase
               include ActionDispatch::TestProcess
               self.use_transactional_fixtures = true
               self.use_instantiated_fixtures  = false
               def uploaded_test_file(name, mime)
                 fixture_file_upload("files/#{name}", mime, true)
               end
               # Mock out a file
               def self.mock_file
                 file = 'a_file.png'
                 file.stubs(:size).returns(32)
                 file.stubs(:original_filename).returns('a_file.png')
                 file.stubs(:content_type).returns('image/png')
                 file.stubs(:read).returns(false)
                 file
               end
               def mock_file
                 self.class.mock_file
               end
               def mock_file_with_options(options={})
                 file = ''
                 file.stubs(:size).returns(32)
                 original_filename = options[:original_filename] || nil
                 file.stubs(:original_filename).returns(original_filename)
                 content_type = options[:content_type] || nil
                 file.stubs(:content_type).returns(content_type)
                 file.stubs(:read).returns(false)
                 file
               end
               # Use a temporary directory for attachment related tests
               def set_tmp_attachments_directory
                 Dir.mkdir "#{Rails.root}/tmp/test" unless File.directory?("#{Rails.root}/tmp/test")
                 unless File.directory?("#{Rails.root}/tmp/test/attachments")
                   Dir.mkdir "#{Rails.root}/tmp/test/attachments"
                 end
                 Attachment.storage_path = "#{Rails.root}/tmp/test/attachments"
               end
               def set_fixtures_attachments_directory
                 Attachment.storage_path = "#{Rails.root}/test/fixtures/files"
               end
               def with_settings(options, &block)
                 saved_settings = options.keys.inject({}) do |h, k|
                   h[k] = case Setting[k]
                     when Symbol, false, true, nil
                       Setting[k]
                     else
                       Setting[k].dup
                     end
                   h
                 end
                 options.each {|k, v| Setting[k] = v}
                 yield
               ensure
                 saved_settings.each {|k, v| Setting[k] = v} if saved_settings
               end
               # Yields the block with user as the current user
               def with_current_user(user, &block)
                 saved_user = User.current
                 User.current = user
                 yield
               ensure
                 User.current = saved_user
               end
               def with_locale(locale, &block)
                 saved_localed = ::I18n.locale
                 ::I18n.locale = locale
                 yield
               ensure
                 ::I18n.locale = saved_localed
               end
               def self.ldap_configured?
                 @test_ldap = Net::LDAP.new(:host => $redmine_test_ldap_server, :port => 389)
                 return @test_ldap.bind
               rescue Exception => e
                 # LDAP is not listening
                 return nil
               end
               def self.convert_installed?
                 Redmine::Thumbnail.convert_available?
               end
               def convert_installed?
                 self.class.convert_installed?
               end
               # Returns the path to the test +vendor+ repository
               def self.repository_path(vendor)
                 path = Rails.root.join("tmp/test/#{vendor.downcase}_repository").to_s
                 # Unlike ruby, JRuby returns Rails.root with backslashes under Windows
                 path.tr("\\", "/")
               end
               # Returns the url of the subversion test repository
               def self.subversion_repository_url
                 path = repository_path('subversion')
                 path = '/' + path unless path.starts_with?('/')
                 "file://#{path}"
               end
               # Returns true if the +vendor+ test repository is configured
               def self.repository_configured?(vendor)
                 File.directory?(repository_path(vendor))
               end
               def repository_path_hash(arr)
                 hs = {}
                 hs[:path]  = arr.join("/")
                 hs[:param] = arr.join("/")
                 hs
               end
               def sqlite?
                 ActiveRecord::Base.connection.adapter_name =~ /sqlite/i
               end
               def mysql?
                 ActiveRecord::Base.connection.adapter_name =~ /mysql/i
               end
               def postgresql?
                 ActiveRecord::Base.connection.adapter_name =~ /postgresql/i
               end
               def quoted_date(date)
                 date = Date.parse(date) if date.is_a?(String)
                 ActiveRecord::Base.connection.quoted_date(date)
               end
               # Asserts that a new record for the given class is created
               # and returns it
               def new_record(klass, &block)
                 new_records(klass, 1, &block).first
               end
               # Asserts that count new records for the given class are created
               # and returns them as an array order by object id
               def new_records(klass, count, &block)
                 assert_difference "#{klass}.count", count do
                   yield
                 end
                 klass.order(:id => :desc).limit(count).to_a.reverse
               end
               def assert_save(object)
                 saved = object.save
                 message = "#{object.class} could not be saved"
                 errors = object.errors.full_messages.map {|m| "- #{m}"}
                 message << ":\n#{errors.join("\n")}" if errors.any?
                 assert_equal true, saved, message
               end
               def assert_select_error(arg)
                 assert_select '#errorExplanation', :text => arg
               end
               def assert_include(expected, s, message=nil)
                 assert s.include?(expected), (message || "\"#{expected}\" not found in \"#{s}\"")
               end
               def assert_not_include(expected, s, message=nil)
                 assert !s.include?(expected), (message || "\"#{expected}\" found in \"#{s}\"")
               end
               def assert_select_in(text, *args, &block)
                 d = Nokogiri::HTML(CGI::unescapeHTML(String.new(text))).root
                 assert_select(d, *args, &block)
               end
               def assert_select_email(*args, &block)
                 email = ActionMailer::Base.deliveries.last
                 assert_not_nil email
                 html_body = email.parts.detect {|part| part.content_type.include?('text/html')}.try(&:body)
                 assert_not_nil html_body
                 assert_select_in html_body.encoded, *args, &block
               end
               def assert_mail_body_match(expected, mail, message=nil)
                 if expected.is_a?(String)
                   assert_include expected, mail_body(mail), message
                 else
                   assert_match expected, mail_body(mail), message
                 end
               end
               def assert_mail_body_no_match(expected, mail, message=nil)
                 if expected.is_a?(String)
                   assert_not_include expected, mail_body(mail), message
                 else
                   assert_no_match expected, mail_body(mail), message
                 end
               end
               def mail_body(mail)
                 mail.parts.first.body.encoded
               end
               # Returns the lft value for a new root issue
               def new_issue_lft
               end
             end
             module Redmine
               class RoutingTest < ActionDispatch::IntegrationTest
                 def should_route(arg)
                   arg = arg.dup
                   request = arg.keys.detect {|key| key.is_a?(String)}
                   raise ArgumentError unless request
                   options = arg.slice!(request)
                   raise ArgumentError unless request =~ /\A(GET|POST|PUT|PATCH|DELETE)\s+(.+)\z/
                   method, path = $1.downcase.to_sym, $2
                   raise ArgumentError unless arg.values.first =~ /\A(.+)#(.+)\z/
                   controller, action = $1, $2
                   assert_routing(
                     {:method => method, :path => path},
                     options.merge(:controller => controller, :action => action)
                   )
                 end
               end
               class HelperTest < ActionView::TestCase
+                def setup
+                  super
+                  User.current = nil
+                end
               end
               class ControllerTest < ActionController::TestCase
                 # Returns the issues that are displayed in the list in the same order
                 def issues_in_list
                   ids = css_select('tr.issue td.id').map(&:text).map(&:to_i)
                   Issue.where(:id => ids).sort_by {|issue| ids.index(issue.id)}
                 end
                 # Return the columns that are displayed in the list
                 def columns_in_issues_list
                   css_select('table.issues thead th:not(.checkbox)').map(&:text)
                 end
                 # Verifies that the query filters match the expected filters
                 def assert_query_filters(expected_filters)
                   response.body =~ /initFilters\(\);\s*((addFilter\(.+\);\s*)*)/
                   filter_init = $1.to_s
                   expected_filters.each do |field, operator, values|
                     s = "addFilter(#{field.to_json}, #{operator.to_json}, #{Array(values).to_json});"
                     assert_include s, filter_init
                   end
                   assert_equal expected_filters.size, filter_init.scan("addFilter").size, "filters counts don't match"
                 end
                 def process(method, path, parameters={}, session={}, flash={})
                   if parameters.key?(:params) || parameters.key?(:session)
                     raise ArgumentError if session.present?
                     super method, path, parameters[:params], parameters[:session], parameters.except(:params, :session)
                   else
                     super
                   end
                 end
               end
               class IntegrationTest < ActionDispatch::IntegrationTest
                 def log_user(login, password)
                   User.anonymous
                   get "/login"
                   assert_nil session[:user_id]
                   assert_response :success
                   post "/login", :username => login, :password => password
                   assert_equal login, User.find(session[:user_id]).login
                 end
                 def credentials(user, password=nil)
                   {'HTTP_AUTHORIZATION' => ActionController::HttpAuthentication::Basic.encode_credentials(user, password || user)}
                 end
               end
               module ApiTest
                 API_FORMATS = %w(json xml).freeze
                 # Base class for API tests
                 class Base < Redmine::IntegrationTest
                   def setup
                     Setting.rest_api_enabled = '1'
                   end
                   def teardown
                     Setting.rest_api_enabled = '0'
                   end
                   # Uploads content using the XML API and returns the attachment token
                   def xml_upload(content, credentials)
                     upload('xml', content, credentials)
                   end
                   # Uploads content using the JSON API and returns the attachment token
                   def json_upload(content, credentials)
                     upload('json', content, credentials)
                   end
                   def upload(format, content, credentials)
                     set_tmp_attachments_directory
                     assert_difference 'Attachment.count' do
                       post "/uploads.#{format}", content, {"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials)
                       assert_response :created
                     end
                     data = response_data
                     assert_kind_of Hash, data['upload']
                     token = data['upload']['token']
                     assert_not_nil token
                     token
                   end
                   # Parses the response body based on its content type
                   def response_data
                     unless response.content_type.to_s =~ /^application\/(.+)/
                       raise "Unexpected response type: #{response.content_type}"
                     end
                     format = $1
                     case format
                     when 'xml'
                       Hash.from_xml(response.body)
                     when 'json'
                       ActiveSupport::JSON.decode(response.body)
                     else
                       raise "Unknown response format: #{format}"
                     end
                   end
                 end
                 class Routing < Redmine::RoutingTest
                   def should_route(arg)
                     arg = arg.dup
                     request = arg.keys.detect {|key| key.is_a?(String)}
                     raise ArgumentError unless request
                     options = arg.slice!(request)
                     API_FORMATS.each do |format|
                       format_request = request.sub /$/, ".#{format}"
                       super options.merge(format_request => arg[request], :format => format)
                     end
                   end
                 end
               end
             end

test/unit/helpers/activities_helper_test.rb +1 0

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../test_helper', __FILE__)
             class ActivitiesHelperTest < Redmine::HelperTest
               include ActivitiesHelper
               include Redmine::I18n
               class MockEvent
                 attr_reader :event_datetime, :event_group, :name
                 def initialize(group=nil)
                   @@count ||= 0
                   @name = "e#{@@count}"
                   @event_datetime = Time.now + @@count.hours
                   @event_group = group || self
                   @@count += 1
                 end
                 def self.clear
                   @@count = 0
                 end
               end
               def setup
+                super
                 MockEvent.clear
               end
               def test_sort_activity_events_should_sort_by_datetime
                 events = []
                 events << MockEvent.new
                 events << MockEvent.new
                 events << MockEvent.new
                 assert_equal [
                     ['e2', false],
                     ['e1', false],
                     ['e0', false]
                   ], sort_activity_events(events).map {|event, grouped| [event.name, grouped]}
               end
               def test_sort_activity_events_should_group_events
                 events = []
                 events << MockEvent.new
                 events << MockEvent.new(events[0])
                 events << MockEvent.new(events[0])
                 assert_equal [
                     ['e2', false],
                     ['e1', true],
                     ['e0', true]
                   ], sort_activity_events(events).map {|event, grouped| [event.name, grouped]}
               end
               def test_sort_activity_events_with_group_not_in_set_should_group_events
                 e = MockEvent.new
                 events = []
                 events << MockEvent.new(e)
                 events << MockEvent.new(e)
                 assert_equal [
                     ['e2', false],
                     ['e1', true]
                   ], sort_activity_events(events).map {|event, grouped| [event.name, grouped]}
               end
               def test_sort_activity_events_should_sort_by_datetime_and_group
                 events = []
                 events << MockEvent.new
                 events << MockEvent.new
                 events << MockEvent.new
                 events << MockEvent.new(events[1])
                 events << MockEvent.new(events[2])
                 events << MockEvent.new
                 events << MockEvent.new(events[2])
                 assert_equal [
                     ['e6', false],
                     ['e4', true],
                     ['e2', true],
                     ['e5', false],
                     ['e3', false],
                     ['e1', true],
                     ['e0', false]
                   ], sort_activity_events(events).map {|event, grouped| [event.name, grouped]}
               end
             end

test/unit/helpers/issues_helper_test.rb 0 -1

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../test_helper', __FILE__)
             class IssuesHelperTest < Redmine::HelperTest
               include Redmine::I18n
               include IssuesHelper
               include CustomFieldsHelper
               include ERB::Util
               include Rails.application.routes.url_helpers
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :custom_fields,
                        :attachments,
                        :versions
               def setup
                 super
                 set_language_if_valid('en')
-                User.current = nil
               end
               def test_issue_heading
                 assert_equal "Bug #1", issue_heading(Issue.find(1))
               end
               def test_issues_destroy_confirmation_message_with_one_root_issue
                 assert_equal l(:text_issues_destroy_confirmation),
                              issues_destroy_confirmation_message(Issue.find(1))
               end
               def test_issues_destroy_confirmation_message_with_an_arrayt_of_root_issues
                 assert_equal l(:text_issues_destroy_confirmation),
                              issues_destroy_confirmation_message(Issue.find([1, 2]))
               end
               def test_issues_destroy_confirmation_message_with_one_parent_issue
                 Issue.find(2).update! :parent_issue_id => 1
                 assert_equal l(:text_issues_destroy_confirmation) + "\n" +
                                l(:text_issues_destroy_descendants_confirmation, :count => 1),
                              issues_destroy_confirmation_message(Issue.find(1))
               end
               def test_issues_destroy_confirmation_message_with_one_parent_issue_and_its_child
                 Issue.find(2).update! :parent_issue_id => 1
                 assert_equal l(:text_issues_destroy_confirmation),
                              issues_destroy_confirmation_message(Issue.find([1, 2]))
               end
               def test_issues_destroy_confirmation_message_with_issues_that_share_descendants
                 root = Issue.generate!
                 child = Issue.generate!(:parent_issue_id => root.id)
                 Issue.generate!(:parent_issue_id => child.id)
                 assert_equal l(:text_issues_destroy_confirmation) + "\n" +
                                l(:text_issues_destroy_descendants_confirmation, :count => 1),
                              issues_destroy_confirmation_message([root.reload, child.reload])
               end
               test 'show_detail with no_html should show a changing attribute' do
                 detail = JournalDetail.new(:property => 'attr', :old_value => '40',
                                            :value => '100', :prop_key => 'done_ratio')
                 assert_equal "% Done changed from 40 to 100", show_detail(detail, true)
               end
               test 'show_detail with no_html should show a new attribute' do
                 detail = JournalDetail.new(:property => 'attr', :old_value => nil,
                                            :value => '100', :prop_key => 'done_ratio')
                 assert_equal "% Done set to 100", show_detail(detail, true)
               end
               test 'show_detail with no_html should show a deleted attribute' do
                 detail = JournalDetail.new(:property => 'attr', :old_value => '50',
                                            :value => nil, :prop_key => 'done_ratio')
                 assert_equal "% Done deleted (50)", show_detail(detail, true)
               end
               test 'show_detail with html should show a changing attribute with HTML highlights' do
                 detail = JournalDetail.new(:property => 'attr', :old_value => '40',
                                            :value => '100', :prop_key => 'done_ratio')
                 html = show_detail(detail, false)
                 assert_include '<strong>% Done</strong>', html
                 assert_include '<i>40</i>', html
                 assert_include '<i>100</i>', html
               end
               test 'show_detail with html should show a new attribute with HTML highlights' do
                 detail = JournalDetail.new(:property => 'attr', :old_value => nil,
                                            :value => '100', :prop_key => 'done_ratio')
                 html = show_detail(detail, false)
                 assert_include '<strong>% Done</strong>', html
                 assert_include '<i>100</i>', html
               end
               test 'show_detail with html should show a deleted attribute with HTML highlights' do
                 detail = JournalDetail.new(:property => 'attr', :old_value => '50',
                                            :value => nil, :prop_key => 'done_ratio')
                 html = show_detail(detail, false)
                 assert_include '<strong>% Done</strong>', html
                 assert_include '<del><i>50</i></del>', html
               end
               test 'show_detail with a start_date attribute should format the dates' do
                 detail = JournalDetail.new(
                            :property  => 'attr',
                            :old_value => '2010-01-01',
                            :value     => '2010-01-31',
                            :prop_key  => 'start_date'
                         )
                 with_settings :date_format => '%m/%d/%Y' do
                   assert_match "01/31/2010", show_detail(detail, true)
                   assert_match "01/01/2010", show_detail(detail, true)
                 end
               end
               test 'show_detail with a due_date attribute should format the dates' do
                 detail = JournalDetail.new(
                           :property  => 'attr',
                           :old_value => '2010-01-01',
                           :value     => '2010-01-31',
                           :prop_key  => 'due_date'
                         )
                 with_settings :date_format => '%m/%d/%Y' do
                   assert_match "01/31/2010", show_detail(detail, true)
                   assert_match "01/01/2010", show_detail(detail, true)
                 end
               end
               test 'show_detail should show old and new values with a project attribute' do
                 detail = JournalDetail.new(:property => 'attr', :prop_key => 'project_id',
                                            :old_value => 1, :value => 2)
                 assert_match 'eCookbook', show_detail(detail, true)
                 assert_match 'OnlineStore', show_detail(detail, true)
               end
               test 'show_detail should show old and new values with a issue status attribute' do
                 detail = JournalDetail.new(:property => 'attr', :prop_key => 'status_id',
                                            :old_value => 1, :value => 2)
                 assert_match 'New', show_detail(detail, true)
                 assert_match 'Assigned', show_detail(detail, true)
               end
               test 'show_detail should show old and new values with a tracker attribute' do
                 detail = JournalDetail.new(:property => 'attr', :prop_key => 'tracker_id',
                                            :old_value => 1, :value => 2)
                 assert_match 'Bug', show_detail(detail, true)
                 assert_match 'Feature request', show_detail(detail, true)
               end
               test 'show_detail should show old and new values with a assigned to attribute' do
                 detail = JournalDetail.new(:property => 'attr', :prop_key => 'assigned_to_id',
                                            :old_value => 1, :value => 2)
                 assert_match 'Redmine Admin', show_detail(detail, true)
                 assert_match 'John Smith', show_detail(detail, true)
               end
               test 'show_detail should show old and new values with a priority attribute' do
                 detail = JournalDetail.new(:property => 'attr', :prop_key => 'priority_id',
                                            :old_value => 4, :value => 5)
                 assert_match 'Low', show_detail(detail, true)
                 assert_match 'Normal', show_detail(detail, true)
               end
               test 'show_detail should show old and new values with a category attribute' do
                 detail = JournalDetail.new(:property => 'attr', :prop_key => 'category_id',
                                            :old_value => 1, :value => 2)
                 assert_match 'Printing', show_detail(detail, true)
                 assert_match 'Recipes', show_detail(detail, true)
               end
               test 'show_detail should show old and new values with a fixed version attribute' do
                 detail = JournalDetail.new(:property => 'attr', :prop_key => 'fixed_version_id',
                                            :old_value => 1, :value => 2)
                 assert_match '0.1', show_detail(detail, true)
                 assert_match '1.0', show_detail(detail, true)
               end
               test 'show_detail should show old and new values with a estimated hours attribute' do
                 detail = JournalDetail.new(:property => 'attr', :prop_key => 'estimated_hours',
                                            :old_value => '5', :value => '6.3')
                 assert_match '5.00', show_detail(detail, true)
                 assert_match '6.30', show_detail(detail, true)
               end
               test 'show_detail should not show values with a description attribute' do
                 detail = JournalDetail.new(:property => 'attr', :prop_key => 'description',
                                            :old_value => 'Foo', :value => 'Bar')
                 assert_equal 'Description updated', show_detail(detail, true)
               end
               test 'show_detail should show old and new values with a custom field' do
                 detail = JournalDetail.new(:property => 'cf', :prop_key => '1',
                                            :old_value => 'MySQL', :value => 'PostgreSQL')
                 assert_equal 'Database changed from MySQL to PostgreSQL', show_detail(detail, true)
               end
               test 'show_detail should not show values with a long text custom field' do
                 field = IssueCustomField.create!(:name => "Long field", :field_format => 'text')
                 detail = JournalDetail.new(:property => 'cf', :prop_key => field.id,
                                            :old_value => 'Foo', :value => 'Bar')
                 assert_equal 'Long field updated', show_detail(detail, true)
               end
               test 'show_detail should show added file' do
                 detail = JournalDetail.new(:property => 'attachment', :prop_key => '1',
                                            :old_value => nil, :value => 'error281.txt')
                 assert_match 'error281.txt', show_detail(detail, true)
               end
               test 'show_detail should show removed file' do
                 detail = JournalDetail.new(:property => 'attachment', :prop_key => '1',
                                            :old_value => 'error281.txt', :value => nil)
                 assert_match 'error281.txt', show_detail(detail, true)
               end
               def test_show_detail_relation_added
                 detail = JournalDetail.new(:property => 'relation',
                                            :prop_key => 'precedes',
                                            :value    => 1)
                 assert_equal "Precedes Bug #1: Cannot print recipes added", show_detail(detail, true)
                 str = link_to("Bug #1", "/issues/1", :class => Issue.find(1).css_classes)
                 assert_equal "<strong>Precedes</strong> <i>#{str}: Cannot print recipes</i> added",
                               show_detail(detail, false)
               end
               def test_show_detail_relation_added_with_inexistant_issue
                 inexistant_issue_number = 9999
                 assert_nil  Issue.find_by_id(inexistant_issue_number)
                 detail = JournalDetail.new(:property => 'relation',
                                            :prop_key => 'precedes',
                                            :value    => inexistant_issue_number)
                 assert_equal "Precedes Issue ##{inexistant_issue_number} added", show_detail(detail, true)
                 assert_equal "<strong>Precedes</strong> <i>Issue ##{inexistant_issue_number}</i> added", show_detail(detail, false)
               end
               def test_show_detail_relation_added_should_not_disclose_issue_that_is_not_visible
                 issue = Issue.generate!(:is_private => true)
                 detail = JournalDetail.new(:property => 'relation',
                                            :prop_key => 'precedes',
                                            :value    => issue.id)
                 assert_equal "Precedes Issue ##{issue.id} added", show_detail(detail, true)
                 assert_equal "<strong>Precedes</strong> <i>Issue ##{issue.id}</i> added", show_detail(detail, false)
               end
               def test_show_detail_relation_deleted
                 detail = JournalDetail.new(:property  => 'relation',
                                            :prop_key  => 'precedes',
                                            :old_value => 1)
                 assert_equal "Precedes deleted (Bug #1: Cannot print recipes)", show_detail(detail, true)
                 str = link_to("Bug #1",
                               "/issues/1",
                               :class => Issue.find(1).css_classes)
                 assert_equal "<strong>Precedes</strong> deleted (<i>#{str}: Cannot print recipes</i>)",
                              show_detail(detail, false)
               end
               def test_show_detail_relation_deleted_with_inexistant_issue
                 inexistant_issue_number = 9999
                 assert_nil  Issue.find_by_id(inexistant_issue_number)
                 detail = JournalDetail.new(:property  => 'relation',
                                            :prop_key  => 'precedes',
                                            :old_value => inexistant_issue_number)
                 assert_equal "Precedes deleted (Issue #9999)", show_detail(detail, true)
                 assert_equal "<strong>Precedes</strong> deleted (<i>Issue #9999</i>)", show_detail(detail, false)
               end
               def test_show_detail_relation_deleted_should_not_disclose_issue_that_is_not_visible
                 issue = Issue.generate!(:is_private => true)
                 detail = JournalDetail.new(:property => 'relation',
                                            :prop_key => 'precedes',
                                            :old_value    => issue.id)
                 assert_equal "Precedes deleted (Issue ##{issue.id})", show_detail(detail, true)
                 assert_equal "<strong>Precedes</strong> deleted (<i>Issue ##{issue.id}</i>)", show_detail(detail, false)
               end
               def test_details_to_strings_with_multiple_values_removed_from_custom_field
                 field = IssueCustomField.generate!(:name => 'User', :field_format => 'user', :multiple => true)
                 details = []
                 details << JournalDetail.new(:property => 'cf', :prop_key => field.id.to_s, :old_value => '1', :value => nil)
                 details << JournalDetail.new(:property => 'cf', :prop_key => field.id.to_s, :old_value => '3', :value => nil)
                 assert_equal ["User deleted (Dave Lopper, Redmine Admin)"], details_to_strings(details, true)
                 assert_equal ["<strong>User</strong> deleted (<del><i>Dave Lopper, Redmine Admin</i></del>)"], details_to_strings(details, false)
               end
               def test_details_to_strings_with_multiple_values_added_to_custom_field
                 field = IssueCustomField.generate!(:name => 'User', :field_format => 'user', :multiple => true)
                 details = []
                 details << JournalDetail.new(:property => 'cf', :prop_key => field.id.to_s, :old_value => nil, :value => '1')
                 details << JournalDetail.new(:property => 'cf', :prop_key => field.id.to_s, :old_value => nil, :value => '3')
                 assert_equal ["User Dave Lopper, Redmine Admin added"], details_to_strings(details, true)
                 assert_equal ["<strong>User</strong> <i>Dave Lopper, Redmine Admin</i> added"], details_to_strings(details, false)
               end
               def test_details_to_strings_with_multiple_values_added_and_removed_from_custom_field
                 field = IssueCustomField.generate!(:name => 'User', :field_format => 'user', :multiple => true)
                 details = []
                 details << JournalDetail.new(:property => 'cf', :prop_key => field.id.to_s, :old_value => nil, :value => '1')
                 details << JournalDetail.new(:property => 'cf', :prop_key => field.id.to_s, :old_value => '2', :value => nil)
                 details << JournalDetail.new(:property => 'cf', :prop_key => field.id.to_s, :old_value => '3', :value => nil)
                 assert_equal [
                   "User Redmine Admin added",
                   "User deleted (Dave Lopper, John Smith)"
                   ], details_to_strings(details, true)
                 assert_equal [
                   "<strong>User</strong> <i>Redmine Admin</i> added",
                   "<strong>User</strong> deleted (<del><i>Dave Lopper, John Smith</i></del>)"
                   ], details_to_strings(details, false)
               end
               def test_find_name_by_reflection_should_return_nil_for_missing_record
                 assert_nil find_name_by_reflection('status', 99)
               end
             end

test/unit/helpers/projects_helper_test.rb 0 -1

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../test_helper', __FILE__)
             class ProjectsHelperTest < Redmine::HelperTest
               include ApplicationHelper
               include ProjectsHelper
               include Redmine::I18n
               include ERB::Util
               include Rails.application.routes.url_helpers
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :enumerations, :users, :issue_categories,
                        :versions,
                        :projects_trackers,
                        :member_roles,
                        :members,
                        :groups_users,
                        :enabled_modules
               def setup
                 super
                 set_language_if_valid('en')
-                User.current = nil
               end
               def test_link_to_version_within_project
                 @project = Project.find(2)
                 User.current = User.find(1)
                 assert_equal '<a title="07/01/2006" href="/versions/5">Alpha</a>', link_to_version(Version.find(5))
               end
               def test_link_to_version
                 User.current = User.find(1)
                 assert_equal '<a title="07/01/2006" href="/versions/5">OnlineStore - Alpha</a>', link_to_version(Version.find(5))
               end
               def test_link_to_version_without_effective_date
                 User.current = User.find(1)
                 version = Version.find(5)
                 version.effective_date = nil
                 assert_equal '<a href="/versions/5">OnlineStore - Alpha</a>', link_to_version(version)
               end
               def test_link_to_private_version
                 assert_equal 'OnlineStore - Alpha', link_to_version(Version.find(5))
               end
               def test_link_to_version_invalid_version
                 assert_equal '', link_to_version(Object)
               end
               def test_format_version_name_within_project
                 @project = Project.find(1)
                 assert_equal "0.1", format_version_name(Version.find(1))
               end
               def test_format_version_name
                 assert_equal "eCookbook - 0.1", format_version_name(Version.find(1))
               end
               def test_format_version_name_for_system_version
                 assert_equal "OnlineStore - Systemwide visible version", format_version_name(Version.find(7))
               end
               def test_version_options_for_select_with_no_versions
                 assert_equal '', version_options_for_select([])
                 assert_equal '', version_options_for_select([], Version.find(1))
               end
             end

test/unit/helpers/sort_helper_test.rb +1 0

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../test_helper', __FILE__)
             class SortHelperTest < Redmine::HelperTest
               include SortHelper
               include Redmine::I18n
               include ERB::Util
               def setup
+                super
                 @session = nil
                 @sort_param = nil
               end
               def test_default_sort_clause_with_array
                 sort_init 'attr1', 'desc'
                 sort_update(['attr1', 'attr2'])
                 assert_equal ['attr1 DESC'], sort_clause
               end
               def test_default_sort_clause_with_hash
                 sort_init 'attr1', 'desc'
                 sort_update({'attr1' => 'table1.attr1', 'attr2' => 'table2.attr2'})
                 assert_equal ['table1.attr1 DESC'], sort_clause
               end
               def test_default_sort_clause_with_multiple_columns
                 sort_init 'attr1', 'desc'
                 sort_update({'attr1' => ['table1.attr1', 'table1.attr2'], 'attr2' => 'table2.attr2'})
                 assert_equal ['table1.attr1 DESC', 'table1.attr2 DESC'], sort_clause
               end
               def test_params_sort
                 @sort_param = 'attr1,attr2:desc'
                 sort_init 'attr1', 'desc'
                 sort_update({'attr1' => 'table1.attr1', 'attr2' => 'table2.attr2'})
                 assert_equal ['table1.attr1 ASC', 'table2.attr2 DESC'], sort_clause
                 assert_equal 'attr1,attr2:desc', @session['foo_bar_sort']
               end
               def test_invalid_params_sort
                 @sort_param = 'invalid_key'
                 sort_init 'attr1', 'desc'
                 sort_update({'attr1' => 'table1.attr1', 'attr2' => 'table2.attr2'})
                 assert_equal ['table1.attr1 DESC'], sort_clause
                 assert_equal 'attr1:desc', @session['foo_bar_sort']
               end
               def test_invalid_order_params_sort
                 @sort_param = 'attr1:foo:bar,attr2'
                 sort_init 'attr1', 'desc'
                 sort_update({'attr1' => 'table1.attr1', 'attr2' => 'table2.attr2'})
                 assert_equal ['table1.attr1 ASC', 'table2.attr2 ASC'], sort_clause
                 assert_equal 'attr1,attr2', @session['foo_bar_sort']
               end
               def test_sort_css_without_params_should_use_default_sort
                 sort_init 'attr1', 'desc'
                 sort_update(['attr1', 'attr2'])
                 assert_equal 'sort-by-attr1 sort-desc', sort_css_classes
               end
               def test_sort_css_should_use_params
                 @sort_param = 'attr2,attr1'
                 sort_init 'attr1', 'desc'
                 sort_update(['attr1', 'attr2'])
                 assert_equal 'sort-by-attr2 sort-asc', sort_css_classes
               end
               def test_sort_css_should_dasherize_sort_name
                 sort_init 'foo_bar'
                 sort_update(['foo_bar'])
                 assert_equal 'sort-by-foo-bar sort-asc', sort_css_classes
               end
               private
               def controller_name; 'foo'; end
               def action_name; 'bar'; end
               def params; {:sort => @sort_param}; end
               def session; @session ||= {}; end
             end

test/unit/helpers/timelog_helper_test.rb 0 -4

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../test_helper', __FILE__)
             class TimelogHelperTest < Redmine::HelperTest
               include TimelogHelper
               include Redmine::I18n
               include ActionView::Helpers::TextHelper
               include ActionView::Helpers::DateHelper
               include ERB::Util
               fixtures :projects, :roles, :enabled_modules, :users,
                                   :repositories, :changesets,
                                   :trackers, :issue_statuses, :issues, :versions, :documents,
                                   :wikis, :wiki_pages, :wiki_contents,
                                   :boards, :messages,
                                   :attachments,
                                   :enumerations
-              def setup
-                super
-              end
               def test_activities_collection_for_select_options_should_return_array_of_activity_names_and_ids
                 activities = activity_collection_for_select_options
                 assert activities.include?(["Design", 9])
                 assert activities.include?(["Development", 10])
               end
               def test_activities_collection_for_select_options_should_not_include_inactive_activities
                 activities = activity_collection_for_select_options
                 assert !activities.include?(["Inactive Activity", 14])
               end
               def test_activities_collection_for_select_options_should_use_the_projects_override
                 project = Project.find(1)
                 override_activity = TimeEntryActivity.create!({:name => "Design override", :parent => TimeEntryActivity.find_by_name("Design"), :project => project})
                 activities = activity_collection_for_select_options(nil, project)
                 assert !activities.include?(["Design", 9]), "System activity found in: " + activities.inspect
                 assert activities.include?(["Design override", override_activity.id]), "Override activity not found in: " + activities.inspect
               end
             end

test/unit/helpers/watchers_helper_test.rb 0 -1

             # Redmine - project management software
             # Copyright (C) 2006-2016  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../test_helper', __FILE__)
             class WatchersHelperTest < Redmine::HelperTest
               include WatchersHelper
               include Redmine::I18n
               include Rails.application.routes.url_helpers
               fixtures :users, :issues
               def setup
                 super
                 set_language_if_valid('en')
-                User.current = nil
               end
               test '#watcher_link with a non-watched object' do
                 expected = link_to(
                   "Watch",
                   "/watchers/watch?object_id=1&object_type=issue",
                   :remote => true, :method => 'post', :class => "issue-1-watcher icon icon-fav-off"
                 )
                 assert_equal expected, watcher_link(Issue.find(1), User.find(1))
               end
               test '#watcher_link with a single objet array' do
                 expected = link_to(
                   "Watch",
                   "/watchers/watch?object_id=1&object_type=issue",
                   :remote => true, :method => 'post', :class => "issue-1-watcher icon icon-fav-off"
                 )
                 assert_equal expected, watcher_link([Issue.find(1)], User.find(1))
               end
               test '#watcher_link with a multiple objets array' do
                 expected = link_to(
                   "Watch",
                   "/watchers/watch?object_id%5B%5D=1&object_id%5B%5D=3&object_type=issue",
                   :remote => true, :method => 'post', :class => "issue-bulk-watcher icon icon-fav-off"
                 )
                 assert_equal expected, watcher_link([Issue.find(1), Issue.find(3)], User.find(1))
               end
               def test_watcher_link_with_nil_should_return_empty_string
                 assert_equal '', watcher_link(nil, User.find(1))
               end
               test '#watcher_link with a watched object' do
                 Watcher.create!(:watchable => Issue.find(1), :user => User.find(1))
                 expected = link_to(
                   "Unwatch",
                   "/watchers/watch?object_id=1&object_type=issue",
                   :remote => true, :method => 'delete', :class => "issue-1-watcher icon icon-fav"
                 )
                 assert_equal expected, watcher_link(Issue.find(1), User.find(1))
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages