revised_holidays 9.0.0

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/integration/test_all_regions.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+class AllRegionsTests < Test::Unit::TestCase
+  def setup
+    Holidays::LoadAllDefinitions.call
+  end
+
+  def test_definition_dir
+    assert File.directory?(Holidays::FULL_DEFINITIONS_PATH)
+  end
+
+  def test_show_available_regions
+    regions = Holidays.available_regions
+
+    assert_equal regions.size, Holidays::REGIONS.size
+    assert_equal regions, Holidays::REGIONS
+  end
+
+  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::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::InvalidRegion do
+      Holidays.between(Date.civil(2014, 1, 1), Date.civil(2016, 1, 1), '../../../../../../../../../../../../tmp/profile_pic.jpg')
+    end
+  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 259, Holidays.available_regions.count
+  end
+end

data/test/integration/test_custom_holidays.rb

@@ -0,0 +1,41 @@
+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::InvalidRegion do
+      Holidays.on(Date.civil(2013,6,20), :custom_single_file)
+    end
+
+    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
+
+  def test_load_custom_returns_loaded_holidays
+    expected_loaded_holidays = {6=>[{:mday=>20, :name=>"Company Founding", :regions=>[:custom_single_file]}]}
+
+    assert_equal expected_loaded_holidays, Holidays.load_custom('test/data/test_single_custom_holiday_defs.yaml')
+  end
+
+  def test_custom_holidays_present_after_multiple_file_parsing
+    assert_raises Holidays::InvalidRegion do
+      Holidays.on(Date.civil(2013, 10,5), :custom_multiple_files)
+    end
+
+    assert_raises Holidays::InvalidRegion do
+      Holidays.on(Date.civil(2013,3,1), :custom_multiple_files)
+    end
+
+    assert_raises Holidays::InvalidRegion do
+      Holidays.on(Date.civil(2013,3,1), :custom_multiple_files_govt)
+    end
+
+    Holidays.load_custom('test/data/test_multiple_custom_holiday_defs.yaml', 'test/data/test_custom_govt_holiday_defs.yaml')
+
+    assert_not_equal [], Holidays.on(Date.civil(2013,10,5), :custom_multiple_files)
+    assert_not_equal [], Holidays.on(Date.civil(2013,3,1), :custom_multiple_files)
+    assert_not_equal [], Holidays.on(Date.civil(2013,3,1), :custom_multiple_files_govt)
+  end
+
+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/integration/test_custom_year_range_holidays.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+class CustomYearRangeHolidaysTest < Test::Unit::TestCase
+
+  def test_after_year_feature
+    Holidays.load_custom('test/data/test_custom_year_range_holiday_defs.yaml')
+    assert_equal [], Holidays.on(Date.civil(2015,6,1), :custom_year_range_file)
+    assert_not_equal [], Holidays.on(Date.civil(2016,6,1), :custom_year_range_file)
+  end
+
+  def test_before_year_feature
+    Holidays.load_custom('test/data/test_custom_year_range_holiday_defs.yaml')
+    assert_not_equal [], Holidays.on(Date.civil(2017,6,2), :custom_year_range_file)
+    assert_equal [], Holidays.on(Date.civil(2018,6,2), :custom_year_range_file)
+  end
+
+  def test_between_year_feature
+    Holidays.load_custom('test/data/test_custom_year_range_holiday_defs.yaml')
+    assert_equal [], Holidays.on(Date.civil(2015,6,3), :custom_year_range_file)
+    assert_not_equal [], Holidays.on(Date.civil(2016,6,3), :custom_year_range_file)
+    assert_not_equal [], Holidays.on(Date.civil(2017,6,3), :custom_year_range_file)
+    assert_not_equal [], Holidays.on(Date.civil(2018,6,3), :custom_year_range_file)
+    assert_equal [], Holidays.on(Date.civil(2019,6,3), :custom_year_range_file)
+  end
+
+  def test_limited_year_feature
+    Holidays.load_custom('test/data/test_custom_year_range_holiday_defs.yaml')
+    assert_equal [], Holidays.on(Date.civil(2015,6,4), :custom_year_range_file)
+    assert_not_equal [], Holidays.on(Date.civil(2016,6,4), :custom_year_range_file)
+    assert_equal [], Holidays.on(Date.civil(2017,6,4), :custom_year_range_file)
+    assert_not_equal [], Holidays.on(Date.civil(2018,6,4), :custom_year_range_file)
+    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
+end

data/test/integration/test_holidays.rb

@@ -0,0 +1,243 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+class HolidaysTests < Test::Unit::TestCase
+  def setup
+    @date = Date.civil(2008,1,1)
+  end
+
+  def test_on
+    h = Holidays.on(Date.civil(2008,9,1), :ca)
+    assert_equal 'Labour Day', h[0][:name]
+
+    holidays = Holidays.on(Date.civil(2008,7,4), :ca)
+    assert_equal 0, holidays.length
+  end
+
+  def test_requires_valid_regions
+    assert_raises Holidays::InvalidRegion do
+      Holidays.on(Date.civil(2008,1,1), :xx)
+    end
+
+    assert_raises Holidays::InvalidRegion do
+      Holidays.on(Date.civil(2008,1,1), [:ca,:xx])
+    end
+
+    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::InvalidRegion do
+      Holidays.next_holidays(1, [:xx], Date.civil(2008,1,1))
+    end
+
+    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::InvalidRegion do
+      Holidays.next_holidays(1, [:ca,:xx])
+    end
+  end
+
+  def test_region_params
+    holidays = Holidays.on(@date, :ca)
+    assert_equal 1, holidays.length
+
+    holidays = Holidays.on(@date, [:ca_bc,:ca])
+    assert_equal 1, holidays.length
+  end
+
+  def test_observed_dates
+    # Should fall on Tuesday the 1st
+   assert_equal 1, Holidays.on(Date.civil(2008,7,1), :ca, :observed).length
+
+    # Should fall on Monday the 2nd
+    assert_equal 1, Holidays.on(Date.civil(2007,7,2), :ca, :observed).length
+  end
+
+  def test_any_region
+    # 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 0, holidays.length
+
+    # Should return Victoria Day and National Patriotes Day.
+    #
+    # Should be 2 in the CA region but other regional files are loaded during the
+    # unit tests add to the :any count.
+    holidays = Holidays.between(Date.civil(2008,5,1), Date.civil(2008,5,31), [:any])
+    assert holidays.length >= 2
+
+    # Test blank region
+    holidays = Holidays.between(Date.civil(2008,5,1), Date.civil(2008,5,31))
+    assert holidays.length >= 3
+  end
+
+  def test_any_region_holiday_next
+    # Should return Victoria Day.
+    holidays = Holidays.next_holidays(1, [:ca], Date.civil(2008,5,1))
+    assert_equal 1, holidays.length
+    assert_equal ['2008-07-01','Canada Day'] , [holidays.first[:date].to_s, holidays.first[:name].to_s]
+
+    # Should return 2 holidays.
+    holidays = Holidays.next_holidays(2, [:ca], Date.civil(2008,5,1))
+    assert_equal 2, holidays.length
+
+    # Should return 1 holiday in July
+    holidays = Holidays.next_holidays(1, [:jp], Date.civil(2016, 5, 22))
+    assert_equal ['2016-07-18','海の日'] , [holidays.first[:date].to_s, holidays.first[:name].to_s]
+
+    # Must Region.If there is not region, raise ArgumentError.
+    assert_raises ArgumentError do
+      Holidays.next_holidays(2, '', Date.civil(2008,5,1))
+    end
+    # Options should be present.If they are empty, raise ArgumentError.
+    assert_raises ArgumentError do
+      Holidays.next_holidays(2, [], Date.civil(2008,5,1))
+    end
+    # Options should be Array.If they are not Array, raise ArgumentError.
+    assert_raises ArgumentError do
+      Holidays.next_holidays(2, :ca, Date.civil(2008,5,1))
+    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_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 11, 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 nothing (Victoria Day is no longer :ca wide)
+    holidays = Holidays.between(Date.civil(2008,5,1), Date.civil(2008,5,31), :ca)
+    assert_equal 0, holidays.length
+
+    ## Should return National Patriotes Day.
+    holidays = Holidays.between(Date.civil(2008,5,1), Date.civil(2008,5,31), :ca_qc)
+    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 3, holidays.length
+  end
+
+  def test_sub_regions_holiday_next
+    # Should return Victoria Day.
+    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-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
+
+    # 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
+    [Date.civil(1800,4,11), Date.civil(1899,3,31), Date.civil(1900,4,13),
+     Date.civil(2008,3,21), Date.civil(2035,3,23)].each do |date|
+      assert_equal 'Good Friday', Holidays.on(date, :ca)[0][:name]
+    end
+
+    [Date.civil(1800,4,14), Date.civil(1899,4,3), Date.civil(1900,4,16),
+     Date.civil(2008,3,24), Date.civil(2035,3,26)].each do |date|
+      assert_equal 'Easter Monday', Holidays.on(date, :ca_qc, :informal)[0][:name]
+    end
+  end
+
+  def test_sorting
+    (1..10).each{|year|
+      (1..12).each{|month|
+        holidays = Holidays.between(Date.civil(year, month, 1), Date.civil(year, month, 28), :gb_)
+        holidays.each_with_index{|holiday, index|
+          assert holiday[:date] >= holidays[index - 1][:date] if index > 0
+        }
+      }
+    }
+  end
+
+  def test_caching
+    good_friday = Date.civil(2008, 3, 21)
+    easter_monday = Date.civil(2008, 3, 24)
+    cache_end_date = Date.civil(2008, 3, 25)
+
+    Holidays.cache_between(good_friday, cache_end_date, :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(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
+
+  def test_load_all
+    Holidays.load_all
+    assert_equal 259, Holidays.available_regions.count
+  end
+end