fixed-33941.patch - Redmine

       def register_automatically(user, &block)
         # Automatic activation
         user.activate
         user.last_login_on = Time.now
         user.last_login_on = Time.current
         if user.save
           self.logged_user = user
           flash[:notice] = l(:notice_account_activated)

           end
         end
         events = @activity.events(@date_from, @date_to)
         events = @activity.events(@date_from.beginning_of_day, @date_to.end_of_day)
         if events.empty? || stale?(:etag => [@activity.scope, @date_to, @date_from, @with_subprojects, @author, events.first, events.size, User.current, current_language])
           respond_to do |format|

       end
       def date_for_user_time_zone(y, m, d)
         if tz = User.current.time_zone
           tz.local y, m, d
         else
           Time.local y, m, d
         end
         (User.current.time_zone || Time.current.time_zone).local y, m, d
       end
       # Returns a SQL clause for a date or datetime field.
       def date_clause(table, field, from, to, is_custom_filter)
         field_type = Module.const_get("#{table}".classify).columns_hash["#{field}"].type rescue nil
         s = []
         if from
           if from.is_a?(Date)
             from = date_for_user_time_zone(from.year, from.month, from.day).yesterday.end_of_day
           else
             from = from - 1 # second
           end
           if self.class.default_timezone == :utc
             from = from.utc
           end
           s << ("#{table}.#{field} > '%s'" % [quoted_time(from, is_custom_filter)])
         end
         if to
           if to.is_a?(Date)
             to = date_for_user_time_zone(to.year, to.month, to.day).end_of_day
         if field_type == :date
+          {
             :from => from,
             :to => to,
           }.each do |key, val|
             next unless val
             val = val.to_date
             s << ("#{table}.#{field} #{key == :from ? '>=' : '<='} '%s'" % [self.class.connection.quoted_date(val)])
           end
           if self.class.default_timezone == :utc
             to = to.utc
         else
+          {
             :from => from,
             :to => to,
           }.each do |key, val|
             next unless val
             if val.is_a?(Date)
               val = date_for_user_time_zone(val.year, val.month, val.day)
               val = val.yesterday if key == :from
               val = val.end_of_day
             else
               val = val + (key == :from ? -1 : 0) # second
             end
             if self.class.default_timezone == :utc
               val = val.utc
             end
             s << ("#{table}.#{field} #{key == :from ? '>' : '<='} '%s'" % [quoted_time(val, is_custom_filter)])
           end
           s << ("#{table}.#{field} <= '%s'" % [quoted_time(to, is_custom_filter)])
         end
         s.join(' AND ')
       end

       # Hash used to cache setting values
       @cached_settings = {}
       @cached_cleared_on = Time.now
       @cached_cleared_on = Time.current
       def value
         v = read_attribute(:value)
-...
       # Clears the settings cache
       def self.clear_cache
         @cached_settings.clear
         @cached_cleared_on = Time.now
         @cached_cleared_on = Time.current
         logger.info "Settings cache cleared." if logger
       end

         end
         if validity_time
           Time.now - validity_time
           Time.current - validity_time
         end
       end

       def salt_password(clear_password)
         self.salt = User.generate_salt
         self.hashed_password = User.hash_password("#{salt}#{User.hash_password clear_password}")
         self.passwd_changed_on = Time.now.change(:usec => 0)
         self.passwd_changed_on = Time.current.change(:usec => 0)
       end
       # Does the backend storage allow this user to change their password?
-...
       end
       def time_zone
         @time_zone ||= (self.pref.time_zone.blank? ? nil : ActiveSupport::TimeZone[self.pref.time_zone])
         @time_zone ||= (self.pref.time_zone.blank? ? Time.current.time_zone : ActiveSupport::TimeZone[self.pref.time_zone])
       end
       def force_default_language?
-...
       # Returns the current day according to user's time zone
       def today
         if time_zone.nil?
           Date.today
         else
           time_zone.today
         end
         time_zone&.today || Date.current
       end
       # Returns the day of +time+ according to user's time zone
-...
       end
       def convert_time_to_user_timezone(time)
         if self.time_zone
           time.in_time_zone(self.time_zone)
         else
           time.utc? ? time.localtime : time
         end
         time.in_time_zone(self.time_zone || Time.current.time_zone)
       end
       def logged?

       xml.link    "rel" => "alternate", "href" => url_for(:params => request.query_parameters.merge(:format => nil, :key => nil), :only_path => false, :protocol => protocol, :host => host)
       xml.id      home_url
       xml.icon    favicon_url
       xml.updated((@items.first ? @items.first.event_datetime : Time.now).xmlschema)
       xml.updated((@items.first ? @items.first.event_datetime : Time.current).xmlschema)
       xml.author  { xml.name "#{Setting.app_title}" }
       xml.generator(:uri => Redmine::Info.url) { xml.text! Redmine::Info.app_name; }
       @items.each do |item|

       xml.link    "rel" => "alternate", "href" => home_url
       xml.id      home_url
       xml.icon    favicon_url
       xml.updated((@journals.first ? @journals.first.event_datetime : Time.now).xmlschema)
       xml.updated((@journals.first ? @journals.first.event_datetime : Time.current).xmlschema)
       xml.author  { xml.name "#{Setting.app_title}" }
       @journals.each do |change|
         issue = change.issue

           def timestamp_to_date(column, time_zone)
             if postgresql?
               if time_zone
                 identifier = ActiveSupport::TimeZone.find_tzinfo(time_zone.name).identifier
                 "(#{column}::timestamptz AT TIME ZONE '#{identifier}')::date"
                 offset_tz = time_zone.utc_offset
                 offset_default =
                   Time.now.__send__(ActiveRecord::Base.default_timezone == :utc ? :utc : :localtime).utc_offset
                 "(#{column} + INTERVAL '#{offset_tz - offset_default} SECOND')::date"
               else
                 "#{column}::date"
               end
             elsif mysql?
               if time_zone
                 user_identifier = ActiveSupport::TimeZone.find_tzinfo(time_zone.name).identifier
                 local_identifier = ActiveSupport::TimeZone.find_tzinfo(Time.zone.name).identifier
                 "DATE(CONVERT_TZ(#{column},'#{local_identifier}', '#{user_identifier}'))"
                 offset_tz = time_zone.utc_offset
                 offset_default =
                   Time.now.__send__(ActiveRecord::Base.default_timezone == :utc ? :utc : :localtime).utc_offset
                 "DATE(#{column} + INTERVAL #{offset_tz - offset_default} SECOND)"
               else
                 "DATE(#{column})"
               end

       assigned_to_id:
       author_id: 2
       status_id: 1
       start_date: <%= Date.today.to_s(:db) %>
       start_date: <%= Date.current.to_s(:db) %>
       due_date: <%= 1.days.from_now.to_date.to_s(:db) %>
       root_id: 6
       lft: 1
-...
       author_id: 2
       status_id: 1
       start_date: <%= 10.days.ago.to_s(:db) %>
       due_date: <%= Date.today.to_s(:db) %>
       due_date: <%= Date.current.to_s(:db) %>
       lock_version: 0
       root_id: 7
       lft: 1
-...
       assigned_to_id:
       author_id: 2
       status_id: 1
       start_date: <%= Date.today.to_s(:db) %>
       start_date: <%= Date.current.to_s(:db) %>
       due_date: <%= 1.days.from_now.to_date.to_s(:db) %>
       root_id: 9
       lft: 1
-...
       assigned_to_id:
       author_id: 2
       status_id: 1
       start_date: <%= Date.today.to_s(:db) %>
       start_date: <%= Date.current.to_s(:db) %>
       due_date: <%= 1.days.from_now.to_date.to_s(:db) %>
       root_id: 10
       lft: 1

       end
       def test_index_grouped_by_created_on_if_time_zone_is_utc
         # TODO: test fails with mysql
         skip if mysql?
         skip unless IssueQuery.new.groupable_columns.detect {|c| c.name == :created_on}
         @request.session[:user_id] = 2
         User.find(2).pref.update(time_zone: 'UTC')
         current_user = User.find(2)
         @request.session[:user_id] = current_user.id
         current_user.pref.update(time_zone: 'UTC')
         get(
           :index,
-...
+        )
         assert_response :success
         assert_select 'tr.group span.name', :text => '07/19/2006' do
         group_name = format_date(current_user.convert_time_to_user_timezone(issues(:issues_002).created_on))
         assert_select 'tr.group span.name', :text => group_name do
           assert_select '+ span.count', :text => '2'
         end
       end
-...
+        )
         assert_response :success
         # group_name depends on localtime
         group_name = format_date(Issue.second.created_on.localtime)
         group_name = format_date(current_user.convert_time_to_user_timezone(issues(:issues_002).created_on))
         assert_select 'tr.group span.name', :text => group_name do
           assert_select '+ span.count', :text => '2'
         end
-...
+          )
           assert_response :success
           assert_select 'input[name=?][value=?]', 'issue[start_date]',
                         Date.today.to_s
                         Date.current.to_s
         end
       end
-...
                                :id => Issue.last.id
           issue = Issue.find_by_subject('This is the test_new issue')
           assert_not_nil issue
           assert_equal Date.today, issue.start_date
           assert_equal Date.current, issue.start_date
         end
       end

       def test_due_date_distance_in_words
         to_test = {
           Date.today => 'Due in 0 days',
           Date.today + 1 => 'Due in 1 day',
           Date.today + 100 => 'Due in about 3 months',
           Date.today + 20000 => 'Due in over 54 years',
           Date.today - 1 => '1 day late',
           Date.today - 100 => 'about 3 months late',
           Date.today - 20000 => 'over 54 years late',
           Date.current => 'Due in 0 days',
           Date.current + 1 => 'Due in 1 day',
           Date.current + 100 => 'Due in about 3 months',
           Date.current + 20000 => 'Due in over 54 years',
           Date.current - 1 => '1 day late',
           Date.current - 100 => 'about 3 months late',
           Date.current - 20000 => 'over 54 years late',
+        }
         ::I18n.locale = :en
         to_test.each do |date, expected|

       include ERB::Util
       def test_date_format_setting_options_should_include_human_readable_format
         Date.stubs(:today).returns(Date.parse("2015-07-14"))
         options = date_format_setting_options('en')
         assert_include ["2015-07-14 (yyyy-mm-dd)", "%Y-%m-%d"], options
         travel_to Date.parse("2015-07-14") do
           options = date_format_setting_options('en')
           assert_include ["2015-07-14 (yyyy-mm-dd)", "%Y-%m-%d"], options
         end
       end
     end

       end
       def today
         @today ||= Date.today
         @today ||= Date.current
       end
       private :today
-...
         create_gantt
         [gantt_start - 1, gantt_start].each do |start_date|
           @output_buffer = @gantt.line(start_date, gantt_start, 30, false, 'line', :format => :html, :zoom => 4)
           # the leftmost date (Date.today - 14 days)
           # the leftmost date (Date.current - 14 days)
           assert_select 'div.task_todo[style*="left:0px"]', 1, @output_buffer
           assert_select 'div.task_todo[style*="width:2px"]', 1, @output_buffer
         end
-...
         create_gantt
         [gantt_end, gantt_end + 1].each do |end_date|
           @output_buffer = @gantt.line(gantt_end, end_date, 30, false, 'line', :format => :html, :zoom => 4)
           # the rightmost date (Date.today + 14 days)
           # the rightmost date (Date.current + 14 days)
           assert_select 'div.task_todo[style*="left:112px"]', 1, @output_buffer
           assert_select 'div.task_todo[style*="width:2px"]', 1, @output_buffer
         end

       def test_time_format
         set_language_if_valid 'en'
         now = Time.parse('2011-02-20 15:45:22')
         now = Time.zone.parse('2011-02-20 15:45:22')
         with_settings :time_format => '%H:%M' do
           with_settings :date_format => '' do
             assert_equal '02/20/2011 15:45', format_time(now)
             assert_equal '15:45', format_time(now, false)
             assert_equal now.strftime('%m/%d/%Y %H:%M'), format_time(now)
             assert_equal now.strftime('%H:%M'), format_time(now, false)
           end
           with_settings :date_format => '%Y-%m-%d' do
             assert_equal '2011-02-20 15:45', format_time(now)
             assert_equal '15:45', format_time(now, false)
             assert_equal now.strftime('%Y-%m-%d %H:%M'), format_time(now)
             assert_equal now.strftime('%H:%M'), format_time(now, false)
           end
         end
       end
       def test_time_format_default
         set_language_if_valid 'en'
         now = Time.parse('2011-02-20 15:45:22')
         now = Time.zone.parse('2011-02-20 15:45:22')
         with_settings :time_format => '' do
           with_settings :date_format => '' do
             assert_equal '02/20/2011 03:45 PM', format_time(now)
             assert_equal '03:45 PM', format_time(now, false)
             assert_equal now.strftime('%m/%d/%Y %I:%M %p'), format_time(now)
             assert_equal now.strftime('%I:%M %p'), format_time(now, false)
           end
           with_settings :date_format => '%Y-%m-%d' do
             assert_equal '2011-02-20 03:45 PM', format_time(now)
             assert_equal '03:45 PM', format_time(now, false)
             assert_equal now.strftime('%Y-%m-%d %I:%M %p'), format_time(now)
             assert_equal now.strftime('%I:%M %p'), format_time(now, false)
           end
         end
       end
       def test_utc_time_format
         set_language_if_valid 'en'
         now = Time.now
         now = Time.current
         with_settings :date_format => '%d %m %Y', :time_format => '%H %M' do
           assert_equal now.localtime.strftime('%d %m %Y %H %M'), format_time(now.utc), "User time zone was #{User.current.time_zone}"
           assert_equal now.localtime.strftime('%H %M'), format_time(now.utc, false)
           assert_equal now.strftime('%d %m %Y %H %M'), format_time(now.utc), "User time zone was #{User.current.time_zone}"
           assert_equal now.strftime('%H %M'), format_time(now.utc, false)
         end
       end

         with_settings :default_issue_start_date_to_creation_date => '1' do
           issue = submit_email('ticket_with_cc.eml', :issue => {:project => 'ecookbook'})
           assert issue.is_a?(Issue)
           assert_equal Date.today, issue.start_date
           assert_equal Date.current, issue.start_date
         end
       end

       end
       def test_reminders
         users(:users_003).pref.update_attribute :time_zone, 'UTC' # dlopper
         days = 42
         Mailer.reminders(:days => days)
         assert_equal 1, ActionMailer::Base.deliveries.size
-...
         with_settings :default_language => 'fr' do
           user = User.find(3)
           user.update_attribute :language, ''
           user.pref.update_attribute :time_zone, 'UTC'
           Mailer.reminders(:days => 42)
           assert_equal 1, ActionMailer::Base.deliveries.size
           mail = last_email
-...
       end
       def test_reminders_for_users
         users(:users_003).pref.update_attribute :time_zone, 'UTC' # dlopper
         Mailer.reminders(:days => 42, :users => ['5'])
         assert_equal 0, ActionMailer::Base.deliveries.size # No mail for dlopper
         Mailer.reminders(:days => 42, :users => ['3'])
-...
           Member.create!(:project_id => 1, :principal => group, :role_ids => [1])
           [users(:users_002), users(:users_003)].each do |user| # jsmith, dlopper
             group.users << user
             user.pref.update_attribute :time_zone, 'UTC'
           end
           Issue.update_all(:assigned_to_id => nil)
-...
       def test_reminders_should_sort_issues_by_due_date
         user = User.find(2)
         user.pref.update_attribute :time_zone, 'UTC'
         Issue.generate!(:assigned_to => user, :due_date => 2.days.from_now, :subject => 'quux')
         Issue.generate!(:assigned_to => user, :due_date => 0.days.from_now, :subject => 'baz')
         Issue.generate!(:assigned_to => user, :due_date => 1.days.from_now, :subject => 'qux')

         assert !query.valid?
       end
       def test_date_filter_should_not_accept_invalid_timestamp_values
         query = IssueQuery.new(:name => '_')
         query.add_filter('created_on', '=', ['2011-01-30T24:00:01'])
         assert query.has_filter?('created_on')
         assert !query.valid?
       end
       def test_relative_date_filter_should_not_accept_non_integer_values
         query = IssueQuery.new(:name => '_')
         query.add_filter('created_on', '>t-', ['a'])
-...
       def test_operator_date_equals
         query = IssueQuery.new(:name => '_')
         query.add_filter('due_date', '=', ['2011-07-10'])
         assert_match /issues\.due_date > '#{quoted_date "2011-07-09"} 23:59:59(\.\d+)?' AND issues\.due_date <= '#{quoted_date "2011-07-10"} 23:59:59(\.\d+)?/,
         assert_match /issues\.due_date >= '#{quoted_date '2011-07-10'}' AND issues\.due_date <= '#{quoted_date '2011-07-10'}'/,
                      query.statement
         find_issues_with_query(query)
         query = IssueQuery.new(:name => '_')
         query.add_filter('updated_on', '=', ['2011-07-10'])
         assert_match /issues\.updated_on > '#{quoted_date Time.zone.parse('2011-07-09').end_of_day}' AND issues\.updated_on <= '#{quoted_date Time.zone.parse('2011-07-10').end_of_day}'/,
                      query.statement
         find_issues_with_query(query)
       end
       def test_operator_date_equals_with_timestamp
         query = IssueQuery.new(:name => '_')
         query.add_filter('due_date', '=', ['2011-07-10T19:13:52'])
         assert_match /issues\.due_date >= '#{quoted_date '2011-07-10T19:13:52'}' AND issues\.due_date <= '#{quoted_date '2011-07-10T19:13:52'}'/, query.statement
         find_issues_with_query(query)
         query = IssueQuery.new(:name => '_')
         query.add_filter('updated_on', '=', ['2011-07-10T19:13:52'])
         assert_match /issues\.updated_on > '#{quoted_date '2011-07-10T19:13:51'.to_time}' AND issues\.updated_on <= '#{quoted_date '2011-07-10T19:13:52'.to_time}'/, query.statement
         find_issues_with_query(query)
       end
       def test_operator_date_lesser_than
         query = IssueQuery.new(:name => '_')
         query.add_filter('due_date', '<=', ['2011-07-10'])
         assert_match /issues\.due_date <= '#{quoted_date "2011-07-10"} 23:59:59(\.\d+)?/, query.statement
         assert_match /issues\.due_date <= '#{quoted_date '2011-07-10'}'/, query.statement
         find_issues_with_query(query)
         query = IssueQuery.new(:name => '_')
         query.add_filter('updated_on', '<=', ['2011-07-10'])
         assert_match /issues\.updated_on <= '#{quoted_date Time.zone.parse('2011-07-10').end_of_day}'/, query.statement
         find_issues_with_query(query)
       end
       def test_operator_date_lesser_than_with_timestamp
         query = IssueQuery.new(:name => '_')
         query.add_filter('due_date', '<=', ['2011-07-10T19:13:52'])
         assert_match /issues\.due_date <= '#{quoted_date '2011-07-10T19:13:52'}/, query.statement
         find_issues_with_query(query)
         query = IssueQuery.new(:name => '_')
         query.add_filter('updated_on', '<=', ['2011-07-10T19:13:52'])
         assert_match /issues\.updated_on <= '#{quoted_date "2011-07-10"} 19:13:52/, query.statement
         assert_match /issues\.updated_on <= '#{quoted_date '2011-07-10T19:13:52'.to_time}/, query.statement
         find_issues_with_query(query)
       end
       def test_operator_date_greater_than
         query = IssueQuery.new(:name => '_')
         query.add_filter('due_date', '>=', ['2011-07-10'])
         assert_match /issues\.due_date > '#{quoted_date "2011-07-09"} 23:59:59(\.\d+)?'/, query.statement
         assert_match /issues\.due_date >= '#{quoted_date '2011-07-10'}'/, query.statement
         find_issues_with_query(query)
         query = IssueQuery.new(:name => '_')
         query.add_filter('updated_on', '>=', ['2011-07-10'])
         assert_match /issues\.updated_on > '#{quoted_date Time.zone.parse('2011-07-09').end_of_day}'/, query.statement
         find_issues_with_query(query)
       end
       def test_operator_date_greater_than_with_timestamp
         query = IssueQuery.new(:name => '_')
         query.add_filter('due_date', '>=', ['2011-07-10T19:13:52'])
         assert_match /issues\.due_date >= '#{quoted_date '2011-07-10T19:13:52'}'/, query.statement
         find_issues_with_query(query)
         query = IssueQuery.new(:name => '_')
         query.add_filter('updated_on', '>=', ['2011-07-10T19:13:52'])
         assert_match /issues\.updated_on > '#{quoted_date "2011-07-10"} 19:13:51(\.0+)?'/, query.statement
         assert_match /issues\.updated_on > '#{quoted_date '2011-07-10T19:13:51'.to_time}'/, query.statement
         find_issues_with_query(query)
       end
       def test_operator_date_between
         query = IssueQuery.new(:name => '_')
         query.add_filter('due_date', '><', ['2011-06-23', '2011-07-10'])
         assert_match /issues\.due_date > '#{quoted_date "2011-06-22"} 23:59:59(\.\d+)?' AND issues\.due_date <= '#{quoted_date "2011-07-10"} 23:59:59(\.\d+)?'/,
         assert_match /issues\.due_date >= '#{quoted_date '2011-06-23'}' AND issues\.due_date <= '#{quoted_date '2011-07-10'}'/,
                      query.statement
         find_issues_with_query(query)
         query = IssueQuery.new(:name => '_')
         query.add_filter('updated_on', '><', ['2011-06-23', '2011-07-10'])
         assert_match /issues\.updated_on > '#{quoted_date Time.zone.parse('2011-06-22').end_of_day}' AND issues\.updated_on <= '#{quoted_date Time.zone.parse('2011-07-10').end_of_day}'/,
                      query.statement
         find_issues_with_query(query)
       end
       def test_operator_date_between_with_timestamp
         query = IssueQuery.new(:name => '_')
         query.add_filter('due_date', '><', ['2011-06-23T19:13:52', '2011-07-10T19:13:52'])
         assert_match /issues\.due_date >= '#{quoted_date '2011-06-23T19:13:52'}' AND issues\.due_date <= '#{quoted_date '2011-07-10T19:13:52'}'/,
                      query.statement
         find_issues_with_query(query)
         query = IssueQuery.new(:name => '_')
         query.add_filter('updated_on', '><', ['2011-06-23T19:13:52', '2011-07-10T19:13:52'])
         assert_match /issues\.updated_on > '#{quoted_date '2011-06-23T19:13:51'.to_time}' AND issues\.updated_on <= '#{quoted_date '2011-07-10T19:13:52'.to_time}'/,
                      query.statement
         find_issues_with_query(query)
       end
       def test_operator_in_more_than
         Issue.find(7).update_attribute(:due_date, (Date.today + 15))
         Issue.find(7).update_attribute(:due_date, (Date.current + 15))
         query = IssueQuery.new(:project => Project.find(1), :name => '_')
         query.add_filter('due_date', '>t+', ['15'])
         issues = find_issues_with_query(query)
         assert !issues.empty?
         issues.each {|issue| assert(issue.due_date >= (Date.today + 15))}
         issues.each {|issue| assert(issue.due_date >= (Date.current + 15))}
       end
       def test_operator_in_less_than
-...
         query.add_filter('due_date', '<t+', ['15'])
         issues = find_issues_with_query(query)
         assert !issues.empty?
         issues.each {|issue| assert(issue.due_date <= (Date.today + 15))}
         issues.each {|issue| assert(issue.due_date <= (Date.current + 15))}
       end
       def test_operator_in_the_next_days
-...
         query.add_filter('due_date', '><t+', ['15'])
         issues = find_issues_with_query(query)
         assert !issues.empty?
         issues.each {|issue| assert(issue.due_date >= Date.today && issue.due_date <= (Date.today + 15))}
         issues.each {|issue| assert(issue.due_date >= Date.current && issue.due_date <= (Date.current + 15))}
       end
       def test_operator_less_than_ago
         Issue.find(7).update_attribute(:due_date, (Date.today - 3))
         Issue.find(7).update_attribute(:due_date, (Date.current - 3))
         query = IssueQuery.new(:project => Project.find(1), :name => '_')
         query.add_filter('due_date', '>t-', ['3'])
         issues = find_issues_with_query(query)
         assert !issues.empty?
         issues.each {|issue| assert(issue.due_date >= (Date.today - 3))}
         issues.each {|issue| assert(issue.due_date >= (Date.current - 3))}
       end
       def test_operator_in_the_past_days
         Issue.find(7).update_attribute(:due_date, (Date.today - 3))
         Issue.find(7).update_attribute(:due_date, (Date.current - 3))
         query = IssueQuery.new(:project => Project.find(1), :name => '_')
         query.add_filter('due_date', '><t-', ['3'])
         issues = find_issues_with_query(query)
         assert !issues.empty?
         issues.each {|issue| assert(issue.due_date >= (Date.today - 3) && issue.due_date <= Date.today)}
         issues.each {|issue| assert(issue.due_date >= (Date.current - 3) && issue.due_date <= Date.current)}
       end
       def test_operator_more_than_ago
         Issue.find(7).update_attribute(:due_date, (Date.today - 10))
         Issue.find(7).update_attribute(:due_date, (Date.current - 10))
         query = IssueQuery.new(:project => Project.find(1), :name => '_')
         query.add_filter('due_date', '<t-', ['10'])
         assert query.statement.include?("#{Issue.table_name}.due_date <=")
         issues = find_issues_with_query(query)
         assert !issues.empty?
         issues.each {|issue| assert(issue.due_date <= (Date.today - 10))}
         issues.each {|issue| assert(issue.due_date <= (Date.current - 10))}
       end
       def test_operator_in
         Issue.find(7).update_attribute(:due_date, (Date.today + 2))
         Issue.find(7).update_attribute(:due_date, (Date.current + 2))
         query = IssueQuery.new(:project => Project.find(1), :name => '_')
         query.add_filter('due_date', 't+', ['2'])
         issues = find_issues_with_query(query)
         assert !issues.empty?
         issues.each {|issue| assert_equal((Date.today + 2), issue.due_date)}
         issues.each {|issue| assert_equal((Date.current + 2), issue.due_date)}
       end
       def test_operator_ago
         Issue.find(7).update_attribute(:due_date, (Date.today - 3))
         Issue.find(7).update_attribute(:due_date, (Date.current - 3))
         query = IssueQuery.new(:project => Project.find(1), :name => '_')
         query.add_filter('due_date', 't-', ['3'])
         issues = find_issues_with_query(query)
         assert !issues.empty?
         issues.each {|issue| assert_equal((Date.today - 3), issue.due_date)}
         issues.each {|issue| assert_equal((Date.current - 3), issue.due_date)}
       end
       def test_operator_today
-...
         query.add_filter('due_date', 't', [''])
         issues = find_issues_with_query(query)
         assert !issues.empty?
         issues.each {|issue| assert_equal Date.today, issue.due_date}
         issues.each {|issue| assert_equal Date.current, issue.due_date}
       end
       def test_operator_tomorrow
-...
       end
       def test_range_for_this_week_with_week_starting_on_monday
         I18n.locale = :fr
         assert_equal '1', I18n.t(:general_first_day_of_week)
         Date.stubs(:today).returns(Date.parse('2011-04-29'))
         query = IssueQuery.new(:project => Project.find(1), :name => '_')
         query.add_filter('due_date', 'w', [''])
         assert_match /issues\.due_date > '#{quoted_date "2011-04-24"} 23:59:59(\.\d+)?' AND issues\.due_date <= '#{quoted_date "2011-05-01"} 23:59:59(\.\d+)?/,
                      query.statement
         I18n.locale = :en
         with_locale :fr do
           assert_equal '1', I18n.t(:general_first_day_of_week)
           travel_to Date.parse('2011-04-29') do
             query = IssueQuery.new(:project => Project.find(1), :name => '_')
             query.add_filter('due_date', 'w', [''])
             assert_match /issues\.due_date >= '#{quoted_date '2011-04-25'}' AND issues\.due_date <= '#{quoted_date '2011-05-01'}'/,
                          query.statement
           end
         end
       end
       def test_range_for_this_week_with_week_starting_on_sunday
         I18n.locale = :en
         assert_equal '7', I18n.t(:general_first_day_of_week)
         Date.stubs(:today).returns(Date.parse('2011-04-29'))
         query = IssueQuery.new(:project => Project.find(1), :name => '_')
         query.add_filter('due_date', 'w', [''])
         assert_match /issues\.due_date > '#{quoted_date "2011-04-23"} 23:59:59(\.\d+)?' AND issues\.due_date <= '#{quoted_date "2011-04-30"} 23:59:59(\.\d+)?/,
                      query.statement
         with_locale :en do
           assert_equal '7', I18n.t(:general_first_day_of_week)
           travel_to Date.parse('2011-04-29') do
             query = IssueQuery.new(:project => Project.find(1), :name => '_')
             query.add_filter('due_date', 'w', [''])
             assert_match /issues\.due_date >= '#{quoted_date '2011-04-24'}' AND issues\.due_date <= '#{quoted_date '2011-04-30'}'/,
                          query.statement
           end
         end
       end
       def test_range_for_next_week_with_week_starting_on_monday
         I18n.locale = :fr
         assert_equal '1', I18n.t(:general_first_day_of_week)
         Date.stubs(:today).returns(Date.parse('2011-04-29')) # Friday
         query = IssueQuery.new(:project => Project.find(1), :name => '_')
         query.add_filter('due_date', 'nw', [''])
         assert_match /issues\.due_date > '#{quoted_date "2011-05-01"} 23:59:59(\.\d+)?' AND issues\.due_date <= '#{quoted_date "2011-05-08"} 23:59:59(\.\d+)?/,
                      query.statement
         I18n.locale = :en
         with_locale :fr do
           assert_equal '1', I18n.t(:general_first_day_of_week)
           travel_to Date.parse('2011-04-29') do
             query = IssueQuery.new(:project => Project.find(1), :name => '_')
             query.add_filter('due_date', 'nw', [''])
             assert_match /issues\.due_date >= '#{quoted_date '2011-05-02'}' AND issues\.due_date <= '#{quoted_date '2011-05-08'}'/,
                          query.statement
           end
         end
       end
       def test_range_for_next_week_with_week_starting_on_sunday
         I18n.locale = :en
         assert_equal '7', I18n.t(:general_first_day_of_week)
         Date.stubs(:today).returns(Date.parse('2011-04-29')) # Friday
         query = IssueQuery.new(:project => Project.find(1), :name => '_')
         query.add_filter('due_date', 'nw', [''])
         assert_match /issues\.due_date > '#{quoted_date "2011-04-30"} 23:59:59(\.\d+)?' AND issues\.due_date <= '#{quoted_date "2011-05-07"} 23:59:59(\.\d+)?/,
                      query.statement
         with_locale :en do
           assert_equal '7', I18n.t(:general_first_day_of_week)
           travel_to Date.parse('2011-04-29') do
             query = IssueQuery.new(:project => Project.find(1), :name => '_')
             query.add_filter('due_date', 'nw', [''])
             assert_match /issues\.due_date >= '#{quoted_date '2011-05-01'}' AND issues\.due_date <= '#{quoted_date '2011-05-07'}'/,
                          query.statement
           end
         end
       end
       def test_range_for_next_month
         Date.stubs(:today).returns(Date.parse('2011-04-29')) # Friday
         query = IssueQuery.new(:project => Project.find(1), :name => '_')
         query.add_filter('due_date', 'nm', [''])
         assert_match /issues\.due_date > '#{quoted_date "2011-04-30"} 23:59:59(\.\d+)?' AND issues\.due_date <= '#{quoted_date "2011-05-31"} 23:59:59(\.\d+)?/,
                      query.statement
         travel_to Date.parse('2011-04-29') do
           query = IssueQuery.new(:project => Project.find(1), :name => '_')
           query.add_filter('due_date', 'nm', [''])
           assert_match /issues\.due_date >= '#{quoted_date '2011-05-01'}' AND issues\.due_date <= '#{quoted_date '2011-05-31'}'/,
                        query.statement
         end
       end
       def test_filter_assigned_to_me

       def test_today_should_return_the_day_according_to_user_time_zone
         preference = User.find(1).pref
         date = Date.new(2012, 05, 15)
         time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
         Date.stubs(:today).returns(date)
         Time.stubs(:now).returns(time)
         preference.update_attribute :time_zone, 'Baku' # UTC+4
         assert_equal '2012-05-16', User.find(1).today.to_s
         travel_to Time.gm(2012, 05, 15, 23, 30).utc do
           preference.update_attribute :time_zone, 'Baku' # UTC+4
           assert_equal '2012-05-16', User.find(1).today.to_s
         preference.update_attribute :time_zone, 'La Paz' # UTC-4
         assert_equal '2012-05-15', User.find(1).today.to_s
           preference.update_attribute :time_zone, 'La Paz' # UTC-4
           assert_equal '2012-05-15', User.find(1).today.to_s
         preference.update_attribute :time_zone, ''
         assert_equal '2012-05-15', User.find(1).today.to_s
           preference.update_attribute :time_zone, ''
           assert_equal Date.current.to_s, User.find(1).today.to_s
         end
       end
       def test_time_to_date_should_return_the_date_according_to_user_time_zone
-...
         assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
         preference.update_attribute :time_zone, ''
         assert_equal time.localtime.to_date.to_s, User.find(1).time_to_date(time).to_s
         user = User.find(1)
         assert_equal time.in_time_zone(user.time_zone).to_date.to_s, user.time_to_date(time).to_s
       end
       def test_convert_time_to_user_timezone_should_return_the_time_according_to_user_time_zone
-...
         assert_equal '2012-05-15 19:30:00 -0400', User.find(1).convert_time_to_user_timezone(time).to_s
         preference.update_attribute :time_zone, ''
         assert_equal time.localtime.to_s, User.find(1).convert_time_to_user_timezone(time).to_s
         assert_equal time_not_utc, User.find(1).convert_time_to_user_timezone(time_not_utc)
         user = User.find(1)
         assert_equal time.in_time_zone(user.time_zone).to_s, user.convert_time_to_user_timezone(time).to_s
         assert_equal time_not_utc, user.convert_time_to_user_timezone(time_not_utc)
       end
       def test_fields_for_order_statement_should_return_fields_according_user_format_setting

       end
       def test_completed_should_be_false_when_due_today
         version = Version.create!(:project_id => 1, :effective_date => Date.today, :name => 'Due today')
         version = Version.create!(:project_id => 1, :effective_date => Date.current, :name => 'Due today')
         assert_equal false, version.completed?
       end

Project

General

Profile

Redmine

Defect #33941 » fixed-33941.patch