holidays 4.2.0 → 8.4.1

data/test/holidays/finder/rules/test_year_range.rb

@@ -0,0 +1,166 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/finder/rules/year_range'
+
+class FinderRulesYearRangeTests < Test::Unit::TestCase
+  def setup
+    @year = 2015
+    @year_ranges = {between: 1996..2002}
+    @subject = Holidays::Finder::Rules::YearRange
+  end
+
+  def test_returns_error_if_target_year_is_missing
+    assert_raises ArgumentError do
+      @subject.call(nil, @year_ranges)
+    end
+  end
+
+  def test_returns_error_if_target_year_is_not_a_number
+    assert_raises ArgumentError do
+      @subject.call("test", @year_ranges)
+    end
+  end
+
+  def test_returns_error_if_year_ranges_if_nil
+    @year_ranges = []
+    assert_raises ArgumentError do
+      @subject.call(@year, nil)
+    end
+  end
+
+  def test_returns_error_if_year_ranges_contains_only_non_hash
+    @year_ranges = :test
+    assert_raises ArgumentError do
+      @subject.call(@year, @year_ranges)
+    end
+  end
+
+  def test_returns_error_if_year_ranges_is_empty
+    @year_ranges = [{}, {}]
+    assert_raises ArgumentError do
+      @subject.call(@year, @year_ranges)
+    end
+  end
+
+  def test_returns_error_if_year_range_contains_a_hash_with_multiple_entries
+    @year_ranges = {:between => 1996..2002, :after => 2002}
+    assert_raises ArgumentError do
+      @subject.call(@year, @year_ranges)
+    end
+  end
+
+  def test_returns_error_if_year_range_contains_unrecognized_operator
+    @year_ranges = {:what => 2002}
+    assert_raises ArgumentError do
+      @subject.call(@year, @year_ranges)
+    end
+  end
+
+  def test_returns_error_if_until_operator_and_value_is_not_a_number
+    @year_ranges = {until: "bad"}
+    assert_raises ArgumentError do
+      @subject.call(@year, @year_ranges)
+    end
+  end
+
+  def test_returns_true_if_until_operator_and_target_is_until
+    @year_ranges = {until: 2000}
+    assert_equal(true, @subject.call(1999, @year_ranges))
+  end
+
+  def test_returns_true_if_until_operator_and_target_is_equal
+    @year_ranges = {until: 2000}
+    assert_equal(true, @subject.call(2000, @year_ranges))
+  end
+
+  def test_returns_false_if_until_operator_and_target_is_after
+    @year_ranges = {until: 2000}
+    assert_equal(false, @subject.call(2001, @year_ranges))
+  end
+
+  def test_returns_error_if_from_operator_with_bad_value
+    @year_ranges = {from: "bad"}
+    assert_raises ArgumentError do
+      @subject.call(@year, @year_ranges)
+    end
+  end
+
+  def test_returns_false_if_from_operator_and_target_is_before
+    @year_ranges = {from: 2000}
+    assert_equal(false, @subject.call(1999, @year_ranges))
+  end
+
+  def test_returns_true_if_from_operator_and_target_is_equal
+    @year_ranges = {from: 2000}
+    assert_equal(true, @subject.call(2000, @year_ranges))
+  end
+
+  def test_returns_true_if_from_operator_and_target_is_after
+    @year_ranges = {from: 2000}
+    assert_equal(true, @subject.call(2001, @year_ranges))
+  end
+
+  def test_returns_error_if_limited_operator_and_bad_value
+    @year_ranges = {limited: "bad"}
+    assert_raises ArgumentError do
+      @subject.call(@year, @year_ranges)
+    end
+  end
+
+  def test_returns_error_if_limited_operator_with_empty_array
+    @year_ranges = {limited: []}
+    assert_raises ArgumentError do
+      @subject.call(@year, @year_ranges)
+    end
+  end
+
+  def test_returns_error_if_limited_operator_with_array_containing_non_integer_value
+    @year_ranges = {limited: ["bad"]}
+    assert_raises ArgumentError do
+      @subject.call(@year, @year_ranges)
+    end
+  end
+
+  def test_returns_true_if_limited_operator_and_value_is_number_that_matches_target
+    @year_ranges = {limited: [2002]}
+    assert_equal(true, @subject.call(2002, @year_ranges))
+  end
+
+  def test_returns_false_if_limited_operator_and_target_is_not_included
+    @year_ranges = {limited: [1998,2000]}
+    assert_equal(false, @subject.call(1997, @year_ranges))
+    assert_equal(false, @subject.call(1999, @year_ranges))
+    assert_equal(false, @subject.call(2002, @year_ranges))
+  end
+
+  def test_returns_true_if_limited_operator_and_target_is_included
+    @year_ranges = {limited: [1998, 2000, 2002]}
+    assert_equal(true, @subject.call(1998, @year_ranges))
+    assert_equal(true, @subject.call(2000, @year_ranges))
+    assert_equal(true, @subject.call(2002, @year_ranges))
+  end
+
+  def test_returns_error_if_between_operator_and_value_not_a_range
+    @year_ranges = {between: 2000}
+    assert_raises ArgumentError do
+      @subject.call(2003, @year_ranges)
+    end
+  end
+
+  def test_returns_false_if_between_operator_and_target_is_before
+    @year_ranges = {between: 1998..2002}
+    assert_equal(false, @subject.call(1997, @year_ranges))
+  end
+
+  def test_returns_true_if_between_operator_and_target_is_covered
+    @year_ranges = {between: 1998..2002}
+    assert_equal(true, @subject.call(1998, @year_ranges))
+    assert_equal(true, @subject.call(2000, @year_ranges))
+    assert_equal(true, @subject.call(2002, @year_ranges))
+  end
+
+  def test_returns_false_if_between_operator_and_target_is_after
+    @year_ranges = {between: 1998..2002}
+    assert_equal(false, @subject.call(2003, @year_ranges))
+  end
+end

data/test/integration/README.md

@@ -0,0 +1,9 @@
+# Integration tests
+
+These tests are dependent on the files in /definitions (and, by proxy, /lib/generated_definitions).
+It is possible that these tests will break because of 'unrelated' definition changes. The code
+behind these changes could still be good but since the definitions changed we could see failures.
+
+These are not unit tests. This is not testing whether specific internal code is working. These are
+tests from the consumer perspective. You must recognize that this could fail because of code
+changes unrelated to definition changes.

data/test/{test_all_regions.rb → integration/test_all_regions.rb}

@@ -1,6 +1,6 @@
-require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
 
-class MultipleRegionsTests < Test::Unit::TestCase
+class AllRegionsTests < Test::Unit::TestCase
   def setup
     Holidays::LoadAllDefinitions.call
   end
@@ -19,16 +19,30 @@ class MultipleRegionsTests < Test::Unit::TestCase
   def test_load_subregion
     holidays = Holidays.on(Date.civil(2014, 1, 1), :de_bb)
     assert holidays.any? { |h| h[:name] == 'Neujahrstag' }
+
+    holidays = Holidays.on(Date.civil(2020, 1, 1), :de_bb)
+    assert holidays.any? { |h| h[:name] == 'Neujahrstag' }
+
+    holidays = Holidays.on(Date.civil(2027, 1, 1), :de_bb)
+    assert holidays.any? { |h| h[:name] == 'Neujahrstag' }
   end
 
   def test_unknown_region_raises_exception
-    assert_raise Holidays::UnknownRegionError do
+    assert_raise Holidays::InvalidRegion do
       Holidays.on(Date.civil(2014, 1, 1), :something_we_do_not_recognize)
     end
+
+    assert_raise Holidays::InvalidRegion do
+      Holidays.on(Date.civil(2020, 1, 1), :something_we_do_not_recognize)
+    end
+
+    assert_raise Holidays::InvalidRegion do
+      Holidays.on(Date.civil(2030, 1, 1), :something_we_do_not_recognize)
+    end
   end
 
   def test_malicious_load_attempt_raises_exception
-    assert_raise Holidays::UnknownRegionError do
+    assert_raise Holidays::InvalidRegion do
       Holidays.between(Date.civil(2014, 1, 1), Date.civil(2016, 1, 1), '../../../../../../../../../../../../tmp/profile_pic.jpg')
     end
   end

data/test/integration/test_any_holidays_during_work_week.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+class AnyHolidaysDuringWorkWeekTests < Test::Unit::TestCase
+  def subject
+    Holidays.method(:any_holidays_during_work_week?)
+  end
+
+  def test_returns_true_when_single_holiday_exists_during_week
+    assert subject.call(Date.new(2018, 1, 1), :us)
+  end
+
+  def test_returns_true_when_multiple_holidays_exist_during_week
+    assert subject.call(Date.new(2018, 12, 26), :gb)
+  end
+
+  def test_returns_true_if_informal_flag_set_and_informal_holiday_exists_during_week
+    assert subject.call(Date.new(2018, 10, 31), :us, :informal)
+  end
+
+  def test_returns_true_when_no_region_specified_and_single_holiday_exists_during_week
+    assert subject.call(Date.new(2018, 1, 1))
+  end
+
+  def test_returns_true_if_both_informal_and_observed_flags_set_and_informal_holiday_observed_during_week
+    assert subject.call(Date.new(2008, 11, 30), :gb_sct, :informal, :observed)
+  end
+
+  def test_returns_true_when_observed_flag_set_and_holiday_is_observed_during_week
+    assert subject.call(Date.new(2012,9,5), :us, :observed)
+  end
+
+  def test_returns_true_when_observed_flag_set_and_holiday_is_observed_on_monday
+    assert subject.call(Date.new(2018,11,12), :us, :observed)
+  end
+
+  def test_returns_true_with_multiple_regions_and_holiday_occurs_during_week
+    assert subject.call(Date.new(2018,1,1), [:us, :gb])
+  end
+
+  def test_returns_true_when_observed_flag_set_and_holiday_on_saturday_but_observed_on_friday
+    assert subject.call(Date.new(2018,7,3), [:us], :observed)
+  end
+
+  def test_returns_false_when_no_holiday_exists_during_week
+    assert_equal false, subject.call(Date.new(2018,7,30), :us)
+  end
+
+  def test_returns_false_when_holiday_on_sunday
+    assert_equal false, subject.call(Date.new(2018,11,11), :us)
+  end
+
+  def test_returns_false_when_holiday_on_saturday
+    assert_equal false, subject.call(Date.new(2017,11,11), :us)
+  end
+
+  def test_returns_false_when_observed_flag_not_set_and_holiday_occurs_on_sunday_but_observed_on_monday
+    assert_equal false, subject.call(Date.new(2017,1,1), :us)
+  end
+
+  def test_returns_false_if_informal_and_observed_flags_both_set_and_no_holiday_exists_during_week
+    assert_equal false, subject.call(Date.new(2018,7,30), :us, :informal, :observed)
+  end
+
+  def test_returns_false_when_informal_flag_set_and_informal_holiday_occurs_on_weekend
+    assert_equal false, subject.call(Date.new(2018,4,14), :us, :informal)
+  end
+
+  def test_returns_false_when_informal_flag_set_but_observed_is_not_and_informal_holiday_is_observed_on_monday
+    assert_equal false, subject.call(Date.new(2008, 11, 30), :gb_sct, :informal)
+  end
+
+  def test_verify_count_of_weeks_without_any_holidays_for_2012
+    weeks_in_2012 = Date.commercial(2013, -1).cweek
+    holidays_in_2012 = weeks_in_2012.times.count { |week| subject.call(Date.commercial(2012,week+1), :us) == false }
+    assert_equal 45, holidays_in_2012
+  end
+
+  def test_returns_true_for_new_years_in_any_region
+    assert subject.call(Date.civil(2016, 1, 1))
+  end
+
+  # These are in response to https://github.com/holidays/holidays/issues/264, just to be completely sure it's fixed.
+  def returns_true_for_various_holidays_in_poland
+    assert subject.call(Date.civil(2018, 1, 1), :pl)
+    assert subject.call(Date.civil(2018, 1, 2), :pl)
+    assert subject.call(Date.civil(2018, 5, 2), :pl)
+    assert subject.call(Date.civil(2018, 5, 3), :pl)
+    assert subject.call(Date.today, Date.today + 365*2, :pl, :observed)
+  end
+end

data/test/integration/test_available_regions.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+class AvailableRegionsTests < Test::Unit::TestCase
+  def setup
+    @date = Date.civil(2008,1,1)
+  end
+
+  def test_available_regions_returns_array
+    assert Holidays.available_regions.is_a?(Array)
+  end
+
+  def test_available_regions_returns_array_of_symbols
+    Holidays.available_regions.each do |r|
+      assert r.is_a?(Symbol)
+    end
+  end
+
+  # This test might fail if we add new regions. Since this is an integration test
+  # I am fine with that!
+  def test_available_regions_returns_correct_number_of_regions
+    assert_equal 258, Holidays.available_regions.count
+  end
+end

data/test/{test_custom_holidays.rb → integration/test_custom_holidays.rb}

@@ -1,13 +1,13 @@
-require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
 
 class CustomHolidaysTest < Test::Unit::TestCase
 
   def test_custom_region_present_after_single_file_parsing
-    assert_raises Holidays::UnknownRegionError do
+    assert_raises Holidays::InvalidRegion do
       Holidays.on(Date.civil(2013,6,20), :custom_single_file)
     end
 
-    loaded_holidays = Holidays.load_custom('test/data/test_single_custom_holiday_defs.yaml')
+    Holidays.load_custom('test/data/test_single_custom_holiday_defs.yaml')
 
     assert_not_equal [], Holidays.on(Date.civil(2013,6,20), :custom_single_file)
   end
@@ -19,15 +19,15 @@ class CustomHolidaysTest < Test::Unit::TestCase
   end
 
   def test_custom_holidays_present_after_multiple_file_parsing
-    assert_raises Holidays::UnknownRegionError do
+    assert_raises Holidays::InvalidRegion do
       Holidays.on(Date.civil(2013, 10,5), :custom_multiple_files)
     end
 
-    assert_raises Holidays::UnknownRegionError do
+    assert_raises Holidays::InvalidRegion do
       Holidays.on(Date.civil(2013,3,1), :custom_multiple_files)
     end
 
-    assert_raises Holidays::UnknownRegionError do
+    assert_raises Holidays::InvalidRegion do
       Holidays.on(Date.civil(2013,3,1), :custom_multiple_files_govt)
     end
 

data/test/integration/test_custom_informal_holidays.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+class CustomHolidaysTest < Test::Unit::TestCase
+
+  def test_custom_region_informal_day_parsing
+    Holidays.load_custom('test/data/test_custom_informal_holidays_defs.yaml')
+
+    assert_not_equal [], Holidays.on(Date.new(2018,1,1), :custom_informal, :informal)
+    assert_equal [], Holidays.on(Date.new(2018,1,1), :custom_informal, :observed)
+
+    assert_not_equal [], Holidays.on(Date.new(2018,1,5), :custom_informal, :informal)
+    assert_equal [], Holidays.on(Date.new(2018,1,5), :custom_informal, :observed)
+  end
+
+end

data/test/{test_custom_year_range_holidays.rb → integration/test_custom_year_range_holidays.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
 
 class CustomYearRangeHolidaysTest < Test::Unit::TestCase
 
@@ -32,12 +32,4 @@ class CustomYearRangeHolidaysTest < Test::Unit::TestCase
     assert_not_equal [], Holidays.on(Date.civil(2019,6,4), :custom_year_range_file)
     assert_equal [], Holidays.on(Date.civil(2020,6,4), :custom_year_range_file)
   end
-
-  def test_multiple_condition
-    Holidays.load_custom('test/data/test_custom_year_range_holiday_defs.yaml')
-    assert_not_equal [], Holidays.on(Date.civil(2015,6,5), :custom_year_range_file)
-    assert_equal [], Holidays.on(Date.civil(2016,6,5), :custom_year_range_file)
-    assert_not_equal [], Holidays.on(Date.civil(2017,6,5), :custom_year_range_file)
-  end
-
 end

data/test/{test_holidays.rb → integration/test_holidays.rb}

@@ -1,14 +1,6 @@
 # encoding: utf-8
-require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
 
-require "#{Holidays::DEFINITIONS_PATH}/ca"
-
-# Re-include CA defs via holidays/north_america to ensure that individual
-# defs aren't duplicated.
-require "#{Holidays::DEFINITIONS_PATH}/north_america"
-
-# These are effectively integration tests. We plan on making this explicit somehow
-# in the future.
 class HolidaysTests < Test::Unit::TestCase
   def setup
     @date = Date.civil(2008,1,1)
@@ -22,55 +14,31 @@ class HolidaysTests < Test::Unit::TestCase
     assert_equal 0, holidays.length
   end
 
-  def test_any_holidays_during_work_week
-    ## Full weeks:
-    # Try with a Monday
-    assert Holidays.any_holidays_during_work_week?(Date.civil(2012,1,23), :us)
-    # Try with a Wednesday
-    assert Holidays.any_holidays_during_work_week?(Date.civil(2012,1,25), :us)
-    # Try Sunday on a week going into a new month
-    assert Holidays.any_holidays_during_work_week?(Date.civil(2012,1,29), :us)
-    # Try Wednesday on a week going into a new month
-    assert Holidays.any_holidays_during_work_week?(Date.civil(2012,2,1), :us)
-
-    ## Weeks with holidays:
-    # New Year's 2012 (on Sunday, observed Monday). Test from a Wednesday.
-    assert_equal(false, Holidays.any_holidays_during_work_week?(Date.civil(2012,1,4), :us))
-    # Ignore observed holidays with :no_observed
-    assert Holidays.any_holidays_during_work_week?(Date.civil(2012,1,4), :us, :no_observed)
-    # Labor Day 2012 should be Sept 3
-    assert_equal(false, Holidays.any_holidays_during_work_week?(Date.civil(2012,9,5), :us))
-    # Should be 10 non-full weeks in the year (in the US)
-    weeks_in_2012 = Date.commercial(2013, -1).cweek
-    holidays_in_2012 = weeks_in_2012.times.count { |week| Holidays.any_holidays_during_work_week?(Date.commercial(2012,week+1), :us) == false }
-    assert_equal 10, holidays_in_2012
-  end
-
   def test_requires_valid_regions
-    assert_raises Holidays::UnknownRegionError do
+    assert_raises Holidays::InvalidRegion do
       Holidays.on(Date.civil(2008,1,1), :xx)
     end
 
-    assert_raises Holidays::UnknownRegionError do
+    assert_raises Holidays::InvalidRegion do
       Holidays.on(Date.civil(2008,1,1), [:ca,:xx])
     end
 
-    assert_raises Holidays::UnknownRegionError do
+    assert_raises Holidays::InvalidRegion do
       Holidays.between(Date.civil(2008,1,1), Date.civil(2008,12,31), [:ca,:xx])
     end
   end
 
   def test_requires_valid_regions_holiday_next
-    assert_raises Holidays::UnknownRegionError do
+    assert_raises Holidays::InvalidRegion do
       Holidays.next_holidays(1, [:xx], Date.civil(2008,1,1))
     end
 
-    assert_raises Holidays::UnknownRegionError do
+    assert_raises Holidays::InvalidRegion do
       Holidays.next_holidays(1, [:ca,:xx], Date.civil(2008,1,1))
       Holidays.on(Date.civil(2008,1,1), [:ca,:xx])
     end
 
-    assert_raises Holidays::UnknownRegionError do
+    assert_raises Holidays::InvalidRegion do
       Holidays.next_holidays(1, [:ca,:xx])
     end
   end
@@ -92,9 +60,9 @@ class HolidaysTests < Test::Unit::TestCase
   end
 
   def test_any_region
-    # Should return Victoria Day.
+    # Should return nothing(Victoria Day is not celebrated :ca wide anymore)
     holidays = Holidays.between(Date.civil(2008,5,1), Date.civil(2008,5,31), :ca)
-    assert_equal 1, holidays.length
+    assert_equal 0, holidays.length
 
     # Should return Victoria Day and National Patriotes Day.
     #
@@ -112,13 +80,10 @@ class HolidaysTests < Test::Unit::TestCase
     # Should return Victoria Day.
     holidays = Holidays.next_holidays(1, [:ca], Date.civil(2008,5,1))
     assert_equal 1, holidays.length
-    assert_equal ['2008-05-19','Victoria Day'] , [holidays.first[:date].to_s, holidays.first[:name].to_s]
+    assert_equal ['2008-07-01','Canada Day'] , [holidays.first[:date].to_s, holidays.first[:name].to_s]
 
     # Should return 2 holidays.
-    #
-    # Should be 2 in the CA region but other regional files are loaded during the
-    # unit tests add to the :any count.
-    holidays = Holidays.next_holidays(2, [:any], Date.civil(2008,5,1))
+    holidays = Holidays.next_holidays(2, [:ca], Date.civil(2008,5,1))
     assert_equal 2, holidays.length
 
     # Should return 1 holiday in July
@@ -139,37 +104,97 @@ class HolidaysTests < Test::Unit::TestCase
     end
   end
 
+  def test_year_holidays
+    # Should return 7 holidays from February 23 to December 31
+    holidays = Holidays.year_holidays([:ca_on], Date.civil(2016, 2, 23))
+    assert_equal 7, holidays.length
+
+    # Must have options (Regions)
+    assert_raises ArgumentError do
+      Holidays.year_holidays([], Date.civil(2016, 2, 23))
+    end
+
+    # Options must be in the form of an array.
+    assert_raises ArgumentError do
+      Holidays.year_holidays(:ca_on, Date.civil(2016, 2, 23))
+    end
+  end
+
+  def test_year_holidays_with_specified_year
+    # Should return all 11 holidays for 2016 in Ontario, Canada
+    holidays = Holidays.year_holidays([:ca_on], Date.civil(2016, 1, 1))
+    assert_equal 9, holidays.length
+
+    # Should return all 5 holidays for 2016 in Australia
+    holidays = Holidays.year_holidays([:au], Date.civil(2016, 1, 1))
+    assert_equal 5, holidays.length
+  end
+
+  def test_year_holidays_without_specified_year
+    # Gets holidays for current year from today's date
+    holidays = Holidays.year_holidays([:de])
+    assert_equal holidays.first[:date].year, Date.today.year
+  end
+
+  def test_year_holidays_empty
+    # if remain holidays is nothing , method will return empty.
+    holidays = Holidays.year_holidays([:ca_on], Date.civil(2016, 12, 27))
+    assert_empty holidays
+  end
+
+  def test_year_holidays_random_years
+    # Should be 1 less holiday, as Family day didn't exist in Ontario in 1990
+    holidays = Holidays.year_holidays([:ca_on], Date.civil(1990, 1, 1))
+    assert_equal 8, holidays.length
+
+    # Family day still didn't exist in 2000
+    holidays = Holidays.year_holidays([:ca_on], Date.civil(2000, 1, 1))
+    assert_equal 8, holidays.length
+
+    holidays = Holidays.year_holidays([:ca_on], Date.civil(2020, 1, 1))
+    assert_equal 9, holidays.length
+
+    holidays = Holidays.year_holidays([:ca_on], Date.civil(2050, 1, 1))
+    assert_equal 9, holidays.length
+
+    holidays = Holidays.year_holidays([:jp], Date.civil(2070, 1, 1))
+    assert_equal 19, holidays.length
+  end
+
   def test_sub_regions
-    # Should return Victoria Day.
+    # Should return nothing (Victoria Day is no longer :ca wide)
     holidays = Holidays.between(Date.civil(2008,5,1), Date.civil(2008,5,31), :ca)
-    assert_equal 1, holidays.length
+    assert_equal 0, holidays.length
 
-    # Should return Victoria Da and National Patriotes Day.
+    ## Should return National Patriotes Day.
     holidays = Holidays.between(Date.civil(2008,5,1), Date.civil(2008,5,31), :ca_qc)
-    assert_equal 2, holidays.length
+    assert_equal 1, holidays.length
 
     # Should return Victoria Day and National Patriotes Day.
     holidays = Holidays.between(Date.civil(2008,5,1), Date.civil(2008,5,31), :ca_)
-    assert_equal 2, holidays.length
+    assert_equal 3, holidays.length
   end
 
   def test_sub_regions_holiday_next
     # Should return Victoria Day.
-    holidays = Holidays.next_holidays(2, [:ca], Date.civil(2008,5,1))
+    holidays = Holidays.next_holidays(2, [:ca_bc], Date.civil(2008,5,1))
     assert_equal 2, holidays.length
     assert_equal ['2008-05-19','Victoria Day'] , [holidays.first[:date].to_s, holidays.first[:name].to_s]
 
     # Should return Victoria Da and National Patriotes Day.
     holidays = Holidays.next_holidays(2, [:ca_qc], Date.civil(2008,5,1))
     assert_equal 2, holidays.length
-    assert_equal ['2008-05-19','Victoria Day'] , [holidays.first[:date].to_s, holidays.first[:name].to_s]
-    assert_equal ['2008-05-19','National Patriotes Day'] , [holidays.last[:date].to_s, holidays.last[:name].to_s]
+    assert_equal ['2008-06-24','Fête Nationale'] , [holidays.last[:date].to_s, holidays.last[:name].to_s]
 
     # Should return Victoria Day and National Patriotes Day.
     holidays = Holidays.next_holidays(2, [:ca_], Date.civil(2008,5,1))
     assert_equal 2, holidays.length
-    assert_equal ['2008-05-19','Victoria Day'] , [holidays.first[:date].to_s, holidays.first[:name].to_s]
-    assert_equal ['2008-05-19','National Patriotes Day'] , [holidays.last[:date].to_s, holidays.last[:name].to_s]
+
+    # Aparently something in jruby doesn't sort the same way as other rubies so....we'll just do it ourselves so
+    # we don't flap.
+    sorted_holidays = holidays.sort_by { |h| h[:name] }
+    assert_equal ['2008-05-19','National Patriotes Day'] , [sorted_holidays.first[:date].to_s, sorted_holidays.first[:name].to_s]
+    assert_equal ['2008-05-19','Victoria Day'] , [sorted_holidays.last[:date].to_s, sorted_holidays.last[:name].to_s]
   end
 
   def test_easter_lambda
@@ -195,24 +220,30 @@ class HolidaysTests < Test::Unit::TestCase
     }
   end
 
-  #FIXME - I am not a huge fan of this test as it is written. It depends on the definitions not changing.
-  #        I think that this is fine for an integration test but I think it should be labeled as such.
   def test_caching
-    start_date = Date.civil(2008, 3, 21)
-    end_date = Date.civil(2008, 3, 25)
-    cache_data = Holidays.between(start_date, end_date, :ca, :informal)
-    options = [:ca, :informal]
+    good_friday = Date.civil(2008, 3, 21)
+    easter_monday = Date.civil(2008, 3, 24)
+    cache_end_date = Date.civil(2008, 3, 25)
 
-    Holidays::DefinitionFactory.cache_repository.expects(:cache_between).with(start_date, end_date, cache_data, options)
+    Holidays.cache_between(good_friday, cache_end_date, :ca, :informal)
 
-    Holidays.cache_between(Date.civil(2008,3,21), Date.civil(2008,3,25), :ca, :informal)
+    # Test that correct results are returned outside the
+    # cache range, and with no caching
+    assert_equal 1, Holidays.on(Date.civil(2035, 1, 1), :ca, :informal).length
+    assert_equal 1, Holidays.on(Date.civil(2035, 1, 1), :us).length
+
+    # Make sure cache is hit for all successive calls
+    Holidays::Factory::Finder.expects(:between).never
 
     # Test that cache has been set and it returns the same as before
-    assert_equal 1, Holidays.on(Date.civil(2008, 3, 21), :ca, :informal).length
-    assert_equal 1, Holidays.on(Date.civil(2008, 3, 24), :ca, :informal).length
+    assert_equal 1, Holidays.on(good_friday, :ca, :informal).length
+    assert_equal 1, Holidays.on(easter_monday, :ca, :informal).length
+    assert_equal 1, easter_monday.holidays(:ca, :informal).length
+    assert_equal true, easter_monday.holiday?(:ca, :informal)
+  end
 
-    # Test that correct results are returned outside the cache range, and with no caching
-    assert_equal 1, Holidays.on(Date.civil(2035,1,1), :ca, :informal).length
-    assert_equal 1, Holidays.on(Date.civil(2035,1,1), :us).length
+  def test_load_all
+    Holidays.load_all
+    assert_equal 258, Holidays.available_regions.count
   end
 end