394 lines
13 KiB
Ruby
394 lines
13 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require_relative "../abstract_unit"
|
|
require "active_support/time"
|
|
require_relative "../core_ext/date_and_time_behavior"
|
|
require_relative "../time_zone_test_helpers"
|
|
|
|
class DateExtCalculationsTest < ActiveSupport::TestCase
|
|
def date_time_init(year, month, day, *args)
|
|
Date.new(year, month, day)
|
|
end
|
|
|
|
include DateAndTimeBehavior
|
|
include TimeZoneTestHelpers
|
|
|
|
def test_yesterday_in_calendar_reform
|
|
assert_equal Date.new(1582, 10, 4), Date.new(1582, 10, 15).yesterday
|
|
end
|
|
|
|
def test_tomorrow_in_calendar_reform
|
|
assert_equal Date.new(1582, 10, 15), Date.new(1582, 10, 4).tomorrow
|
|
end
|
|
|
|
def test_to_s
|
|
date = Date.new(2005, 2, 21)
|
|
assert_equal "2005-02-21", date.to_s
|
|
assert_equal "21 Feb", date.to_s(:short)
|
|
assert_equal "February 21, 2005", date.to_s(:long)
|
|
assert_equal "February 21st, 2005", date.to_s(:long_ordinal)
|
|
assert_equal "2005-02-21", date.to_s(:db)
|
|
assert_equal "2005-02-21", date.to_s(:inspect)
|
|
assert_equal "21 Feb 2005", date.to_s(:rfc822)
|
|
assert_equal "2005-02-21", date.to_s(:iso8601)
|
|
end
|
|
|
|
def test_to_s_with_single_digit_day
|
|
date = Date.new(2005, 2, 1)
|
|
assert_equal "2005-02-01", date.to_s
|
|
assert_equal "01 Feb", date.to_s(:short)
|
|
assert_equal "February 01, 2005", date.to_s(:long)
|
|
assert_equal "February 1st, 2005", date.to_s(:long_ordinal)
|
|
assert_equal "2005-02-01", date.to_s(:db)
|
|
assert_equal "2005-02-01", date.to_s(:inspect)
|
|
assert_equal "01 Feb 2005", date.to_s(:rfc822)
|
|
assert_equal "2005-02-01", date.to_s(:iso8601)
|
|
end
|
|
|
|
def test_readable_inspect
|
|
assert_equal "Mon, 21 Feb 2005", Date.new(2005, 2, 21).readable_inspect
|
|
assert_equal Date.new(2005, 2, 21).readable_inspect, Date.new(2005, 2, 21).inspect
|
|
end
|
|
|
|
def test_to_time
|
|
with_env_tz "US/Eastern" do
|
|
assert_equal Time, Date.new(2005, 2, 21).to_time.class
|
|
assert_equal Time.local(2005, 2, 21), Date.new(2005, 2, 21).to_time
|
|
assert_equal Time.local(2005, 2, 21).utc_offset, Date.new(2005, 2, 21).to_time.utc_offset
|
|
end
|
|
|
|
silence_warnings do
|
|
0.upto(138) do |year|
|
|
[:utc, :local].each do |format|
|
|
assert_equal year, Date.new(year).to_time(format).year
|
|
end
|
|
end
|
|
end
|
|
|
|
assert_raise(ArgumentError) do
|
|
Date.new(2005, 2, 21).to_time(:tokyo)
|
|
end
|
|
end
|
|
|
|
def test_compare_to_time
|
|
assert Date.yesterday < Time.now
|
|
end
|
|
|
|
def test_to_datetime
|
|
assert_equal DateTime.civil(2005, 2, 21), Date.new(2005, 2, 21).to_datetime
|
|
assert_equal 0, Date.new(2005, 2, 21).to_datetime.offset # use UTC offset
|
|
assert_equal ::Date::ITALY, Date.new(2005, 2, 21).to_datetime.start # use Ruby's default start value
|
|
end
|
|
|
|
def test_to_date
|
|
assert_equal Date.new(2005, 2, 21), Date.new(2005, 2, 21).to_date
|
|
end
|
|
|
|
def test_change
|
|
assert_equal Date.new(2005, 2, 21), Date.new(2005, 2, 11).change(day: 21)
|
|
assert_equal Date.new(2007, 5, 11), Date.new(2005, 2, 11).change(year: 2007, month: 5)
|
|
assert_equal Date.new(2006, 2, 22), Date.new(2005, 2, 22).change(year: 2006)
|
|
assert_equal Date.new(2005, 6, 22), Date.new(2005, 2, 22).change(month: 6)
|
|
end
|
|
|
|
def test_sunday
|
|
assert_equal Date.new(2008, 3, 2), Date.new(2008, 3, 02).sunday
|
|
assert_equal Date.new(2008, 3, 2), Date.new(2008, 2, 29).sunday
|
|
end
|
|
|
|
def test_beginning_of_week_in_calendar_reform
|
|
assert_equal Date.new(1582, 10, 1), Date.new(1582, 10, 15).beginning_of_week # friday
|
|
end
|
|
|
|
def test_end_of_week_in_calendar_reform
|
|
assert_equal Date.new(1582, 10, 17), Date.new(1582, 10, 4).end_of_week # thursday
|
|
end
|
|
|
|
def test_end_of_year
|
|
assert_equal Date.new(2008, 12, 31).to_s, Date.new(2008, 2, 22).end_of_year.to_s
|
|
end
|
|
|
|
def test_end_of_month
|
|
assert_equal Date.new(2005, 3, 31), Date.new(2005, 3, 20).end_of_month
|
|
assert_equal Date.new(2005, 2, 28), Date.new(2005, 2, 20).end_of_month
|
|
assert_equal Date.new(2005, 4, 30), Date.new(2005, 4, 20).end_of_month
|
|
end
|
|
|
|
def test_last_year_in_leap_years
|
|
assert_equal Date.new(1999, 2, 28), Date.new(2000, 2, 29).last_year
|
|
end
|
|
|
|
def test_last_year_in_calendar_reform
|
|
assert_equal Date.new(1582, 10, 4), Date.new(1583, 10, 14).last_year
|
|
end
|
|
|
|
def test_advance
|
|
assert_equal Date.new(2006, 2, 28), Date.new(2005, 2, 28).advance(years: 1)
|
|
assert_equal Date.new(2005, 6, 28), Date.new(2005, 2, 28).advance(months: 4)
|
|
assert_equal Date.new(2005, 3, 21), Date.new(2005, 2, 28).advance(weeks: 3)
|
|
assert_equal Date.new(2005, 3, 5), Date.new(2005, 2, 28).advance(days: 5)
|
|
assert_equal Date.new(2012, 9, 28), Date.new(2005, 2, 28).advance(years: 7, months: 7)
|
|
assert_equal Date.new(2013, 10, 3), Date.new(2005, 2, 28).advance(years: 7, months: 19, days: 5)
|
|
assert_equal Date.new(2013, 10, 17), Date.new(2005, 2, 28).advance(years: 7, months: 19, weeks: 2, days: 5)
|
|
assert_equal Date.new(2005, 2, 28), Date.new(2004, 2, 29).advance(years: 1) # leap day plus one year
|
|
end
|
|
|
|
def test_advance_does_first_years_and_then_days
|
|
assert_equal Date.new(2012, 2, 29), Date.new(2011, 2, 28).advance(years: 1, days: 1)
|
|
# If day was done first we would jump to 2012-03-01 instead.
|
|
end
|
|
|
|
def test_advance_does_first_months_and_then_days
|
|
assert_equal Date.new(2010, 3, 29), Date.new(2010, 2, 28).advance(months: 1, days: 1)
|
|
# If day was done first we would jump to 2010-04-01 instead.
|
|
end
|
|
|
|
def test_advance_in_calendar_reform
|
|
assert_equal Date.new(1582, 10, 15), Date.new(1582, 10, 4).advance(days: 1)
|
|
assert_equal Date.new(1582, 10, 4), Date.new(1582, 10, 15).advance(days: -1)
|
|
5.upto(14) do |day|
|
|
assert_equal Date.new(1582, 10, 4), Date.new(1582, 9, day).advance(months: 1)
|
|
assert_equal Date.new(1582, 10, 4), Date.new(1582, 11, day).advance(months: -1)
|
|
assert_equal Date.new(1582, 10, 4), Date.new(1581, 10, day).advance(years: 1)
|
|
assert_equal Date.new(1582, 10, 4), Date.new(1583, 10, day).advance(years: -1)
|
|
end
|
|
end
|
|
|
|
def test_last_week
|
|
assert_equal Date.new(2005, 5, 9), Date.new(2005, 5, 17).last_week
|
|
assert_equal Date.new(2006, 12, 25), Date.new(2007, 1, 7).last_week
|
|
assert_equal Date.new(2010, 2, 12), Date.new(2010, 2, 19).last_week(:friday)
|
|
assert_equal Date.new(2010, 2, 13), Date.new(2010, 2, 19).last_week(:saturday)
|
|
assert_equal Date.new(2010, 2, 27), Date.new(2010, 3, 4).last_week(:saturday)
|
|
end
|
|
|
|
def test_next_week_in_calendar_reform
|
|
assert_equal Date.new(1582, 10, 15), Date.new(1582, 9, 30).next_week(:friday)
|
|
assert_equal Date.new(1582, 10, 18), Date.new(1582, 10, 4).next_week
|
|
end
|
|
|
|
def test_last_quarter_on_31st
|
|
assert_equal Date.new(2004, 2, 29), Date.new(2004, 5, 31).last_quarter
|
|
end
|
|
|
|
def test_yesterday_constructor
|
|
assert_equal Date.current - 1, Date.yesterday
|
|
end
|
|
|
|
def test_yesterday_constructor_when_zone_is_not_set
|
|
with_env_tz "UTC" do
|
|
with_tz_default do
|
|
assert_equal(Date.today - 1, Date.yesterday)
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_yesterday_constructor_when_zone_is_set
|
|
with_env_tz "UTC" do
|
|
with_tz_default ActiveSupport::TimeZone["Eastern Time (US & Canada)"] do # UTC -5
|
|
Time.stub(:now, Time.local(2000, 1, 1)) do
|
|
assert_equal Date.new(1999, 12, 30), Date.yesterday
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_tomorrow_constructor
|
|
assert_equal Date.current + 1, Date.tomorrow
|
|
end
|
|
|
|
def test_tomorrow_constructor_when_zone_is_not_set
|
|
with_env_tz "UTC" do
|
|
with_tz_default do
|
|
assert_equal(Date.today + 1, Date.tomorrow)
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_tomorrow_constructor_when_zone_is_set
|
|
with_env_tz "UTC" do
|
|
with_tz_default ActiveSupport::TimeZone["Europe/Paris"] do # UTC +1
|
|
Time.stub(:now, Time.local(1999, 12, 31, 23)) do
|
|
assert_equal Date.new(2000, 1, 2), Date.tomorrow
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_since
|
|
assert_equal Time.local(2005, 2, 21, 0, 0, 45), Date.new(2005, 2, 21).since(45)
|
|
end
|
|
|
|
def test_since_when_zone_is_set
|
|
zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
|
|
with_env_tz "UTC" do
|
|
with_tz_default zone do
|
|
assert_equal zone.local(2005, 2, 21, 0, 0, 45), Date.new(2005, 2, 21).since(45)
|
|
assert_equal zone, Date.new(2005, 2, 21).since(45).time_zone
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_ago
|
|
assert_equal Time.local(2005, 2, 20, 23, 59, 15), Date.new(2005, 2, 21).ago(45)
|
|
end
|
|
|
|
def test_ago_when_zone_is_set
|
|
zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
|
|
with_env_tz "UTC" do
|
|
with_tz_default zone do
|
|
assert_equal zone.local(2005, 2, 20, 23, 59, 15), Date.new(2005, 2, 21).ago(45)
|
|
assert_equal zone, Date.new(2005, 2, 21).ago(45).time_zone
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_beginning_of_day
|
|
assert_equal Time.local(2005, 2, 21, 0, 0, 0), Date.new(2005, 2, 21).beginning_of_day
|
|
end
|
|
|
|
def test_middle_of_day
|
|
assert_equal Time.local(2005, 2, 21, 12, 0, 0), Date.new(2005, 2, 21).middle_of_day
|
|
end
|
|
|
|
def test_beginning_of_day_when_zone_is_set
|
|
zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
|
|
with_env_tz "UTC" do
|
|
with_tz_default zone do
|
|
assert_equal zone.local(2005, 2, 21, 0, 0, 0), Date.new(2005, 2, 21).beginning_of_day
|
|
assert_equal zone, Date.new(2005, 2, 21).beginning_of_day.time_zone
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_end_of_day
|
|
assert_equal Time.local(2005, 2, 21, 23, 59, 59, Rational(999999999, 1000)), Date.new(2005, 2, 21).end_of_day
|
|
end
|
|
|
|
def test_end_of_day_when_zone_is_set
|
|
zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
|
|
with_env_tz "UTC" do
|
|
with_tz_default zone do
|
|
assert_equal zone.local(2005, 2, 21, 23, 59, 59, Rational(999999999, 1000)), Date.new(2005, 2, 21).end_of_day
|
|
assert_equal zone, Date.new(2005, 2, 21).end_of_day.time_zone
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_all_day
|
|
beginning_of_day = Time.local(2011, 6, 7, 0, 0, 0)
|
|
end_of_day = Time.local(2011, 6, 7, 23, 59, 59, Rational(999999999, 1000))
|
|
assert_equal beginning_of_day..end_of_day, Date.new(2011, 6, 7).all_day
|
|
end
|
|
|
|
def test_all_day_when_zone_is_set
|
|
zone = ActiveSupport::TimeZone["Hawaii"]
|
|
with_env_tz "UTC" do
|
|
with_tz_default zone do
|
|
beginning_of_day = zone.local(2011, 6, 7, 0, 0, 0)
|
|
end_of_day = zone.local(2011, 6, 7, 23, 59, 59, Rational(999999999, 1000))
|
|
assert_equal beginning_of_day..end_of_day, Date.new(2011, 6, 7).all_day
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_all_week
|
|
assert_equal Date.new(2011, 6, 6)..Date.new(2011, 6, 12), Date.new(2011, 6, 7).all_week
|
|
assert_equal Date.new(2011, 6, 5)..Date.new(2011, 6, 11), Date.new(2011, 6, 7).all_week(:sunday)
|
|
end
|
|
|
|
def test_all_month
|
|
assert_equal Date.new(2011, 6, 1)..Date.new(2011, 6, 30), Date.new(2011, 6, 7).all_month
|
|
end
|
|
|
|
def test_all_quarter
|
|
assert_equal Date.new(2011, 4, 1)..Date.new(2011, 6, 30), Date.new(2011, 6, 7).all_quarter
|
|
end
|
|
|
|
def test_all_year
|
|
assert_equal Date.new(2011, 1, 1)..Date.new(2011, 12, 31), Date.new(2011, 6, 7).all_year
|
|
end
|
|
|
|
def test_xmlschema
|
|
with_env_tz "US/Eastern" do
|
|
assert_match(/^1980-02-28T00:00:00-05:?00$/, Date.new(1980, 2, 28).xmlschema)
|
|
assert_match(/^1980-06-28T00:00:00-04:?00$/, Date.new(1980, 6, 28).xmlschema)
|
|
# these tests are only of interest on platforms where older dates #to_time fail over to DateTime
|
|
if ::DateTime === Date.new(1880, 6, 28).to_time
|
|
assert_match(/^1880-02-28T00:00:00-05:?00$/, Date.new(1880, 2, 28).xmlschema)
|
|
assert_match(/^1880-06-28T00:00:00-05:?00$/, Date.new(1880, 6, 28).xmlschema) # DateTimes aren't aware of DST rules
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_xmlschema_when_zone_is_set
|
|
with_env_tz "UTC" do
|
|
with_tz_default ActiveSupport::TimeZone["Eastern Time (US & Canada)"] do # UTC -5
|
|
assert_match(/^1980-02-28T00:00:00-05:?00$/, Date.new(1980, 2, 28).xmlschema)
|
|
assert_match(/^1980-06-28T00:00:00-04:?00$/, Date.new(1980, 6, 28).xmlschema)
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_past
|
|
Date.stub(:current, Date.new(2000, 1, 1)) do
|
|
assert_equal true, Date.new(1999, 12, 31).past?
|
|
assert_equal false, Date.new(2000, 1, 1).past?
|
|
assert_equal false, Date.new(2000, 1, 2).past?
|
|
end
|
|
end
|
|
|
|
def test_future
|
|
Date.stub(:current, Date.new(2000, 1, 1)) do
|
|
assert_equal false, Date.new(1999, 12, 31).future?
|
|
assert_equal false, Date.new(2000, 1, 1).future?
|
|
assert_equal true, Date.new(2000, 1, 2).future?
|
|
end
|
|
end
|
|
|
|
def test_current_returns_date_today_when_zone_not_set
|
|
with_env_tz "US/Central" do
|
|
Time.stub(:now, Time.local(1999, 12, 31, 23)) do
|
|
assert_equal Date.today, Date.current
|
|
end
|
|
end
|
|
end
|
|
|
|
def test_current_returns_time_zone_today_when_zone_is_set
|
|
Time.zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
|
|
with_env_tz "US/Central" do
|
|
assert_equal ::Time.zone.today, Date.current
|
|
end
|
|
ensure
|
|
Time.zone = nil
|
|
end
|
|
|
|
def test_date_advance_should_not_change_passed_options_hash
|
|
options = { years: 3, months: 11, days: 2 }
|
|
Date.new(2005, 2, 28).advance(options)
|
|
assert_equal({ years: 3, months: 11, days: 2 }, options)
|
|
end
|
|
end
|
|
|
|
class DateExtBehaviorTest < ActiveSupport::TestCase
|
|
def test_date_acts_like_date
|
|
assert_predicate Date.new, :acts_like_date?
|
|
end
|
|
|
|
def test_blank?
|
|
assert_not_predicate Date.new, :blank?
|
|
end
|
|
|
|
def test_freeze_doesnt_clobber_memoized_instance_methods
|
|
assert_nothing_raised do
|
|
Date.today.freeze.inspect
|
|
end
|
|
end
|
|
|
|
def test_can_freeze_twice
|
|
assert_nothing_raised do
|
|
Date.today.freeze.freeze
|
|
end
|
|
end
|
|
end
|