holidays 9.2.0 → 10.0.0

data/test/e2e/data/test_multiple_regions_with_conflicts_region_3.yaml

@@ -1,38 +0,0 @@
-months:
-  0:
-  - name: With Function Modifier
-    regions: [multiple_with_conflict_3]
-    function: easter(year)
-    function_modifier: 70
-  - name: With Function Only Different Function Name
-    regions: [multiple_with_conflict_3]
-    function: conflict_custom_method_3(year)
-  - name: With Function Only Same Function Name
-    regions: [multiple_with_conflict_3]
-    function: conflict_custom_method_identical_name_between_regions(year)
-  - name: With Function Only Same Function Name - Region 3
-    regions: [multiple_with_conflict_3]
-    function: conflict_custom_method_identical_name_between_regions_but_different_holiday_names(year)
-  1:
-  - name: New Year's Day
-    regions: [multiple_with_conflict_3]
-    mday: 1
-    observed: to_monday_if_weekend(date)
-  10:
-  - name: Testing Conflict Month 10
-    regions: [multiple_with_conflict_3]
-    mday: 9
-
-methods:
-  conflict_custom_method_3:
-    arguments: year
-    ruby: |
-      Date.civil(year, 4, 1)
-  conflict_custom_method_identical_name_between_regions:
-    arguments: year
-    ruby: |
-      Date.civil(year, 3, 1)
-  conflict_custom_method_identical_name_between_regions_but_different_holiday_names:
-    arguments: year
-    ruby: |
-      Date.civil(year, 3, 15)

data/test/e2e/test_all_regions.rb

@@ -1,49 +0,0 @@
-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/e2e/test_any_holidays_during_work_week.rb

@@ -1,90 +0,0 @@
-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/e2e/test_holidays.rb

@@ -1,244 +0,0 @@
-# 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
-    assert_nothing_raised do
-      Holidays.load_all
-    end
-  end
-end

data/test/e2e/test_holidays_between.rb

@@ -1,87 +0,0 @@
-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.
-#
-# NOTE: this test is a mixture of integration and unit tests. It's messy and bad.
-# I am not fixing it here because I am trying to clean up the 'between' use case
-# and don't want to bite off more than I can chew.
-require "#{Holidays::DEFINITIONS_PATH}/northamerica"
-
-class HolidaysBetweenTests < Test::Unit::TestCase
-  def setup
-    @date = Date.civil(2008,1,1)
-    @subject = Holidays.method(:between)
-  end
-
-  def teardown
-    Holidays::Factory::Definition.cache_repository.reset!
-  end
-
-  def test_between
-    holidays = @subject.call(Date.civil(2008,7,1), Date.civil(2008,7,1), :ca)
-    assert_equal 1, holidays.length
-
-    holidays = @subject.call(Date.civil(2008,7,1), Date.civil(2008,7,31), :ca)
-    assert_equal 1, holidays.length
-
-    holidays = @subject.call(Date.civil(2008,7,2), Date.civil(2008,7,31), :ca)
-    assert_equal 0, holidays.length
-  end
-
-  def test_between_raises_error_if_missing_start_or_end_date
-    assert_raise ArgumentError do
-      @subject.call(nil, Date.civil(2015, 1, 1), :us)
-    end
-
-    assert_raise ArgumentError do
-      @subject.call(Date.civil(2015, 1, 1), nil, :us)
-    end
-  end
-
-  def test_between_raises_error_if_end_date_is_before_start_date
-    assert_raise ArgumentError do
-      @subject.call(Date.civil(2019, 2, 1), Date.civil(2019, 1, 1), :us)
-    end
-
-    assert_raise ArgumentError do
-      @subject.call(Date.civil(2008,7,2), Date.civil(2000,7,2), :ca)
-    end
-  end
-
-  def test_cached_holidays_are_returned_if_present
-    start_date = Date.civil(2015, 1, 1)
-    end_date = Date.civil(2015, 1, 31)
-    options = [:us, :informal]
-
-    Holidays::Factory::Definition.cache_repository.expects(:find).with(start_date, end_date, options).returns({cached: 'data'})
-
-    assert_equal({cached: 'data'}, @subject.call(start_date, end_date, *options))
-  end
-
-  def test_options_are_parsed
-    start_date = Date.civil(2015, 1, 1)
-    end_date = Date.civil(2015, 1, 31)
-    options = [:us]
-
-    between_mock = mock()
-    Holidays::Factory::Finder.stubs(:between).returns(between_mock)
-    between_mock.expects(:call).with(start_date, end_date, [:us])
-
-    @subject.call(start_date, end_date, *options)
-  end
-
-  def test_dates_driver_builder_is_called
-    start_date = Date.civil(2015, 1, 1)
-    end_date = Date.civil(2015, 1, 31)
-    options = [:us]
-
-    between_mock = mock()
-    Holidays::Factory::Finder.stubs(:between).returns(between_mock)
-    between_mock.expects(:call).with(start_date, end_date, [:us])
-
-    @subject.call(start_date, end_date, *options)
-  end
-end

data/test/e2e/test_multiple_regions.rb

@@ -1,71 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
-require "#{Holidays::DEFINITIONS_PATH}/gb"
-require "#{Holidays::DEFINITIONS_PATH}/ie"
-
-class MultipleRegionsTests < Test::Unit::TestCase
-  # Simulate load of new environment where the repositories begin empty
-  def reset_cache
-    Holidays::Factory::Definition.instance_variable_set(:@regions_repo, nil)
-    Holidays::Factory::Definition.instance_variable_set(:@holidays_repo, nil)
-  end
-
-  def test_defining_holidays
-    h = Holidays.on(Date.new(2008, 12, 26), :ie)
-    assert_equal 'St. Stephen\'s Day', h[0][:name]
-
-    h = Holidays.on(Date.new(2008, 5, 9), :gb_)
-    assert_equal 'Liberation Day', (h[0] || {})[:name]
-
-    h = Holidays.on(Date.new(2008, 5, 9), :je)
-    assert_equal 'Liberation Day', h[0][:name]
-
-    h = Holidays.on(Date.new(2008, 5, 9), :gb)
-    assert h.empty?
-  end
-
-  def test_north_american_parent_region_lookup
-    assert_equal :ca, Holidays::PARENT_REGION_LOOKUP[:ca]
-    assert_equal :ca, Holidays::PARENT_REGION_LOOKUP[:ca_qc]
-    assert_equal :mx, Holidays::PARENT_REGION_LOOKUP[:mx]
-    assert_equal :mx, Holidays::PARENT_REGION_LOOKUP[:mx_pue]
-    assert_equal :us, Holidays::PARENT_REGION_LOOKUP[:us]
-    assert_equal :us, Holidays::PARENT_REGION_LOOKUP[:us_fl]
-  end
-
-  def test_north_american_subregion_caching
-    { ca: :ca_qc, mx: :mx_pue, us: :us_fl }.each do |region, subregion|
-      module_name = region.upcase
-
-      reset_cache
-      Holidays.on(Date.new(2018, 1, 1), region)  # Test check on regional holidays
-      assert_equal [region], Holidays::Factory::Definition.regions_repository.all_loaded, "Only Holidays::#{module_name} should be loaded"
-      holiday_regions = Holidays::Factory::Definition.holidays_by_month_repository.all.values.flatten.map { |h| h[:regions] }.uniq.flatten
-      assert_includes holiday_regions, region, 'Region holidays should be loaded'
-      assert_includes holiday_regions, subregion, 'Subregion holidays should be loaded'
-
-      reset_cache
-      Holidays.on(Date.new(2018, 1, 1), subregion)  # Test check on subregional holidays
-      assert_equal [region], Holidays::Factory::Definition.regions_repository.all_loaded, "Only Holidays::#{module_name} should be loaded"
-      holiday_regions = Holidays::Factory::Definition.holidays_by_month_repository.all.values.flatten.map { |h| h[:regions] }.uniq.flatten
-      assert_includes holiday_regions, region, 'Region holidays should be loaded'
-      assert_includes holiday_regions, subregion, 'Subregion holidays should be loaded'
-    end
-  end
-
-  def test_north_american_cross_region_caching
-    reset_cache
-    Holidays.on(Date.new(2018, 1, 1), :us)
-    assert_equal [:us], Holidays::Factory::Definition.regions_repository.all_loaded, 'Only Holidays::US should be loaded'
-    holiday_regions = Holidays::Factory::Definition.holidays_by_month_repository.all.values.flatten.map { |h| h[:regions] }.uniq.flatten
-    assert_includes holiday_regions, :us, 'Region holidays should be loaded'
-    assert_includes holiday_regions, :us_fl, 'Subregion holidays should be loaded'
-
-    Holidays.on(Date.new(2018, 1, 1), :ca)
-    assert_equal [:us, :ca], Holidays::Factory::Definition.regions_repository.all_loaded, 'Only Holidays::US and Holidays::CA should be loaded'
-    holiday_regions = Holidays::Factory::Definition.holidays_by_month_repository.all.values.flatten.map { |h| h[:regions] }.uniq.flatten
-    assert_includes holiday_regions, :us, 'Region holidays should be loaded'
-    assert_includes holiday_regions, :ca, 'Region holidays should be loaded'
-    assert_includes holiday_regions, :us_fl, 'Subregion holidays should be loaded'
-    assert_includes holiday_regions, :ca_qc, 'Subregion holidays should be loaded'
-  end
-end