holidays 9.1.0 → 9.1.2

data/test/e2e/test_multiple_regions_with_conflict.rb

@@ -0,0 +1,228 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+# See https://github.com/holidays/holidays/issues/344 for more info on why
+# these specific integration tests exist.
+class MultipleRegionsWithConflictsTests < Test::Unit::TestCase
+  def test_corpus_christi_returns_correctly_for_co_even_if_br_is_loaded_first
+    result = Holidays.on(Date.new(2014, 6, 19), :br)
+    assert_equal 1, result.count
+    assert_equal 'Corpus Christi', result.first[:name]
+
+    result = Holidays.on(Date.new(2014, 6, 23), :co)
+    assert_equal 1, result.count
+    assert_equal 'Corpus Christi', result.first[:name]
+  end
+
+  def test_custom_loaded_region_returns_correct_value_with_function_modifier_conflict_even_if_conflict_definition_is_loaded_first
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_1.yaml')
+    result = Holidays.on(Date.new(2019, 6, 20), :multiple_with_conflict_1)
+    assert_equal 1, result.count
+    assert_equal 'With Function Modifier', result.first[:name]
+
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_2.yaml')
+    result = Holidays.on(Date.new(2019, 6, 24), :multiple_with_conflict_2)
+    assert_equal 1, result.count
+    assert_equal 'With Function Modifier', result.first[:name]
+
+    # Region 1 must still return the correct date even though region 2 was
+    # loaded afterwards with a different function modifier.
+    result = Holidays.on(Date.new(2019, 6, 20), :multiple_with_conflict_1)
+    assert_equal 1, result.count
+    assert_equal 'With Function Modifier', result.first[:name]
+  end
+
+  def test_custom_loaded_region_returns_correct_value_when_two_regions_share_function_name_but_have_different_logic
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_1.yaml')
+
+    result = Holidays.on(Date.new(2019, 9, 1), :multiple_with_conflict_1)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_2.yaml')
+
+    result = Holidays.on(Date.new(2019, 11, 1), :multiple_with_conflict_2)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+
+    # Region 1 must still return the correct date even though region 2 was
+    # loaded afterwards with the same function name but different logic.
+    result = Holidays.on(Date.new(2019, 9, 1), :multiple_with_conflict_1)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+  end
+
+  # Load region 2 first, then region 1, which is the opposite of the test above.
+  # The first-loaded method lands in @custom_methods; the second goes into
+  # @regional_overrides. This reversal exercises the fallback path for the
+  # first-loaded region rather than the override path.
+  def test_custom_loaded_region_returns_correct_value_when_load_order_is_reversed
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_2.yaml')
+
+    result = Holidays.on(Date.new(2019, 11, 1), :multiple_with_conflict_2)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_1.yaml')
+
+    result = Holidays.on(Date.new(2019, 9, 1), :multiple_with_conflict_1)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+
+    # Region 2 must still return the correct date even though region 1 was
+    # loaded afterwards with the same function name but different logic.
+    result = Holidays.on(Date.new(2019, 11, 1), :multiple_with_conflict_2)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+  end
+
+  # Both regions define holidays with the same custom function name but
+  # different Ruby logic and different holiday names. Because the names differ,
+  # holidays_by_month keeps them as separate entries (no region merge). Conflict
+  # resolution must still route each holiday to its own function implementation.
+  def test_custom_loaded_region_returns_correct_value_when_function_name_is_shared_but_holiday_names_differ
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_1.yaml')
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_2.yaml')
+
+    result = Holidays.on(Date.new(2019, 9, 15), :multiple_with_conflict_1)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name - Region 1', result.first[:name]
+
+    result = Holidays.on(Date.new(2019, 11, 15), :multiple_with_conflict_2)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name - Region 2', result.first[:name]
+  end
+
+  # When two regions are queried together and both have a holiday that uses the
+  # same function name but different logic, the search must evaluate the function
+  # independently for each queried region and return the union of all matches.
+  def test_simultaneous_multi_region_query_evaluates_each_region_function_independently
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_1.yaml')
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_2.yaml')
+
+    result = Holidays.on(Date.new(2019, 11, 1), :multiple_with_conflict_1, :multiple_with_conflict_2)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+
+    result = Holidays.on(Date.new(2019, 9, 1), :multiple_with_conflict_1, :multiple_with_conflict_2)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+  end
+
+  # https://www.github.com/holidays/holidays/issues/344 scenario: two regions
+  # share a function name but each implements it differently, so a single between() call
+  # spanning both result dates must return one holiday entry per region.
+  #
+  # Region 1's function returns Sept 1; region 2's function returns Nov 1.
+  # Querying Sept 1 to Nov 1 with both regions should produce two separate
+  # 'With Function Only Same Function Name' entries, one per region.
+  def test_simultaneous_multi_region_query_returns_one_result_per_region_in_a_single_call
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_1.yaml')
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_2.yaml')
+
+    result = Holidays.between(
+      Date.new(2019, 9, 1),
+      Date.new(2019, 11, 1),
+      :multiple_with_conflict_1,
+      :multiple_with_conflict_2,
+    )
+
+    matching = result.select { |h| h[:name] == 'With Function Only Same Function Name' }
+    assert_equal 2, matching.count
+    assert matching.any? { |h| h[:date] == Date.new(2019, 9, 1) }, 'expected region 1 result on Sept 1'
+    assert matching.any? { |h| h[:date] == Date.new(2019, 11, 1) }, 'expected region 2 result on Nov 1'
+  end
+
+  # Tests the conflict resolution path for functions that take a date argument
+  # and return a shifted date, as opposed to functions that return a fixed date
+  # for a given year. This is the canonical scenario from https://www.github.com/holidays/holidays/issues/344:
+  # two regions define the same function name with different shift logic.
+  #
+  # Region 1: shifts Jan 1 to the nearest upcoming Saturday.
+  # Region 2: shifts Jan 1 to the nearest upcoming Sunday.
+  #
+  # Jan 1, 2025 is a Wednesday, so:
+  #   Region 1 -> Jan 4, 2025 (Saturday, +3 days)
+  #   Region 2 -> Jan 5, 2025 (Sunday,   +4 days)
+  def test_date_transforming_functions_with_conflicting_logic_are_each_evaluated_independently
+    Holidays.load_custom('test/data/test_date_transform_conflict_region_1.yaml')
+    Holidays.load_custom('test/data/test_date_transform_conflict_region_2.yaml')
+
+    # Single-region: each region resolves to its own shifted date.
+    result = Holidays.on(Date.new(2025, 1, 4), :date_transform_conflict_1)
+    assert_equal 1, result.count
+    assert_equal 'Weekend Holiday', result.first[:name]
+
+    result = Holidays.on(Date.new(2025, 1, 5), :date_transform_conflict_2)
+    assert_equal 1, result.count
+    assert_equal 'Weekend Holiday', result.first[:name]
+
+    # Multi-region: a single call spanning both shifted dates must return one
+    # result per region, each evaluated with its own function logic.
+    result = Holidays.between(
+      Date.new(2025, 1, 4),
+      Date.new(2025, 1, 5),
+      :date_transform_conflict_1,
+      :date_transform_conflict_2,
+    )
+
+    matching = result.select { |h| h[:name] == 'Weekend Holiday' }
+    assert_equal 2, matching.count
+    assert matching.any? { |h| h[:date] == Date.new(2025, 1, 4) }, 'expected region 1 result on Jan 4 (Saturday)'
+    assert matching.any? { |h| h[:date] == Date.new(2025, 1, 5) }, 'expected region 2 result on Jan 5 (Sunday)'
+  end
+
+  # Three regions all share the same function name but each implements it with
+  # different logic (region 1 -> Sept 1, region 2 -> Nov 1, region 3 -> Mar 1).
+  # After all three are loaded, every region must still resolve to its own date.
+  def test_three_regions_with_same_function_name_each_return_correct_result
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_1.yaml')
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_2.yaml')
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_3.yaml')
+
+    result = Holidays.on(Date.new(2019, 9, 1), :multiple_with_conflict_1)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+
+    result = Holidays.on(Date.new(2019, 11, 1), :multiple_with_conflict_2)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+
+    result = Holidays.on(Date.new(2019, 3, 1), :multiple_with_conflict_3)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+  end
+
+  # A single between() call across all three regions must return one result per
+  # region, each evaluated with its own function implementation.
+  def test_simultaneous_three_region_query_returns_one_result_per_region
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_1.yaml')
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_2.yaml')
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_3.yaml')
+
+    result = Holidays.between(
+      Date.new(2019, 3, 1),
+      Date.new(2019, 11, 1),
+      :multiple_with_conflict_1,
+      :multiple_with_conflict_2,
+      :multiple_with_conflict_3,
+    )
+
+    matching = result.select { |h| h[:name] == 'With Function Only Same Function Name' }
+    assert_equal 3, matching.count
+    assert matching.any? { |h| h[:date] == Date.new(2019, 3, 1) },  'expected region 3 result on Mar 1'
+    assert matching.any? { |h| h[:date] == Date.new(2019, 9, 1) },  'expected region 1 result on Sept 1'
+    assert matching.any? { |h| h[:date] == Date.new(2019, 11, 1) }, 'expected region 2 result on Nov 1'
+  end
+
+  # Verifies the safe-overwrite path in CustomMethods#add: when the same
+  # source is added again the method is simply overwritten and the holiday
+  # definition repo de-duplicates via uniq!, so exactly one result is returned.
+  def test_loading_the_same_custom_file_twice_does_not_duplicate_or_break_results
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_1.yaml')
+    Holidays.load_custom('test/e2e/data/test_multiple_regions_with_conflicts_region_1.yaml')
+
+    result = Holidays.on(Date.new(2019, 9, 1), :multiple_with_conflict_1)
+    assert_equal 1, result.count
+    assert_equal 'With Function Only Same Function Name', result.first[:name]
+  end
+end

data/test/holidays/definition/context/test_function_processor.rb

@@ -19,7 +19,7 @@ class FunctionProcessorTests < Test::Unit::TestCase
 
     @custom_func = mock()
 
-    @custom_methods_repo.expects(:find).at_most_once.with(@func_id).returns(@custom_func)
+    @custom_methods_repo.expects(:find).at_most_once.with(@func_id, @region).returns(@custom_func)
     @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @year).returns(Date.civil(@year, @month, @day))
 
     @subject = Holidays::Definition::Context::FunctionProcessor.new(
@@ -46,7 +46,7 @@ class FunctionProcessorTests < Test::Unit::TestCase
 
   def test_unknown_function_id_returns_error
     bad_id = "some-bad-id"
-    @custom_methods_repo.expects(:find).at_most_once.with(bad_id).returns(nil)
+    @custom_methods_repo.expects(:find).at_most_once.with(bad_id, @region).returns(nil)
 
     assert_raises Holidays::FunctionNotFound do
       @subject.call(@input, bad_id, @func_args, @func_modifier)

data/test/holidays/definition/context/test_merger.rb

@@ -18,7 +18,7 @@ class MergerTests < Test::Unit::TestCase
   def test_repos_are_called_to_add_regions_and_holidays
     @holidays_repo.expects(:add).with(@target_holidays)
     @regions_repo.expects(:add).with(@target_regions)
-    @custom_methods_repo.expects(:add).with(@target_custom_methods)
+    @custom_methods_repo.expects(:add).with(@target_custom_methods, {}, {})
 
     @subject.call(@target_regions, @target_holidays, @target_custom_methods)
   end

data/test/holidays/finder/context/test_search.rb

@@ -229,4 +229,62 @@ class FinderSearchTests < Test::Unit::TestCase
       @subject.call(@dates_driver, @regions, @options)
     )
   end
+
+  def test_nil_returned_from_one_region_function_does_not_suppress_valid_result_from_other_region
+    two_regions = [:r1, :r2]
+
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns(
+      [{ mday: 1, name: "Test", regions: two_regions, function: "func-id", function_arguments: [:year], function_modifier: nil }]
+    )
+    @in_region_rule.expects(:call).with(two_regions, two_regions).returns(true)
+
+    @custom_method_processor.expects(:call).with(
+      { year: 2015, month: 1, day: 1, region: :r1 }, "func-id", [:year], nil,
+    ).returns(nil)
+
+    @custom_method_processor.expects(:call).with(
+      { year: 2015, month: 1, day: 1, region: :r2 }, "func-id", [:year], nil,
+    ).returns(Date.civil(2015, 6, 15))
+
+    result = @subject.call(@dates_driver, two_regions, [])
+    assert_equal 1, result.count
+    assert_equal Date.civil(2015, 6, 15), result.first[:date]
+  end
+
+  def test_conflicting_function_in_two_regions_evaluates_each_independently
+    two_regions = [:r1, :r2]
+
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns(
+      [{ mday: 1, name: "Test", regions: two_regions, function: "func-id", function_arguments: [:year], function_modifier: nil }]
+    )
+    @in_region_rule.expects(:call).with(two_regions, two_regions).returns(true)
+
+    @custom_method_processor.expects(:call).with(
+      { year: 2015, month: 1, day: 1, region: :r1 }, "func-id", [:year], nil,
+    ).returns(Date.civil(2015, 3, 10))
+
+    @custom_method_processor.expects(:call).with(
+      { year: 2015, month: 1, day: 1, region: :r2 }, "func-id", [:year], nil,
+    ).returns(Date.civil(2015, 6, 15))
+
+    result = @subject.call(@dates_driver, two_regions, [])
+    assert_equal 2, result.count
+    assert result.any? { |h| h[:date] == Date.civil(2015, 3, 10) }
+    assert result.any? { |h| h[:date] == Date.civil(2015, 6, 15) }
+  end
+
+  def test_any_region_query_with_function_evaluates_function_exactly_once
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns(
+      [{ mday: 1, name: "Test", regions: [:r1], function: "func-id", function_arguments: [:year], function_modifier: nil }]
+    )
+    @in_region_rule.expects(:call).with([:any], [:r1]).returns(true)
+
+    @custom_method_processor.expects(:call).with(
+      { year: 2015, month: 1, day: 1, region: :any }, "func-id", [:year], nil,
+    ).returns(Date.civil(2015, 3, 10))
+
+    result = @subject.call(@dates_driver, [:any], [])
+    assert_equal 1, result.count
+    assert_equal Date.civil(2015, 3, 10), result.first[:date]
+  end
 end

data/test/integration/README.md

@@ -1,9 +1,48 @@
 # 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.
+True gem integration tests that verify how the gem's components work together
+(loader, calculator, observed-date logic, sub-region inheritance, caching, etc.)
+using **local fixture YAMLs**. Integration-only fixtures live in
+`test/integration/data/`. Fixtures shared with other test categories live in
+`test/data/`.
 
-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.
+## Purpose
+
+These tests pin specific inputs (the fixture YAMLs) and assert specific outputs,
+so they verify gem behavior independently of whatever the upstream definitions
+repo currently ships. They do not break when upstream definitions change.
+
+## Integration tests vs. unit tests
+
+Unit tests live alongside the code they cover and verify a single file or
+class in isolation. They are the right place for testing the internals of one
+specific component (e.g. a date calculator, a custom method validator) with
+mocks and minimal setup.
+
+Integration tests in this directory are the opposite: they wire multiple gem
+components together and verify that they cooperate correctly across the full
+parse → calculate → return pipeline. If you are testing one file's internal
+behavior, write a unit test. If you are testing how several pieces of the gem
+behave together against a known input, write an integration test here.
+
+## What belongs here
+
+- Tests that exercise gem internals end-to-end (parsing, calculation, output)
+  using controlled inputs from `test/integration/data/` (or `test/data/` for
+  fixtures shared with other test categories).
+- Tests for custom-method evaluation, year-range handling, informal flag
+  filtering, observed-date shifting, sub-region inheritance, etc., using fixtures.
+
+## What does NOT belong here
+
+- Any test that loads or asserts against real definitions in `/definitions`.
+  Those belong in `e2e/`.
+- Pure structural checks that don't assert specific behavior. Those belong in
+  `smoke/`.
+- Tests of a single file or class in isolation. Those are unit tests and belong
+  next to the code they cover.
+
+The advantage of fixture-based tests: a definitions change cannot break them.
+If you find yourself writing a test that needs to load `:ca` or `:us` directly,
+ask whether the same behavior could be tested with a small fixture YAML, and
+if so, write the fixture instead.

data/test/integration/test_custom_holidays.rb

@@ -31,7 +31,7 @@ class CustomHolidaysTest < Test::Unit::TestCase
       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')
+    Holidays.load_custom('test/integration/data/test_multiple_custom_holiday_defs.yaml', 'test/integration/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)

data/test/integration/test_custom_informal_holidays.rb

@@ -3,7 +3,7 @@ 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')
+    Holidays.load_custom('test/integration/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)

data/test/smoke/README.md

@@ -0,0 +1,31 @@
+# Smoke tests
+
+Structural-only checks across every region loaded from `/definitions`. These tests
+verify that the gem can load and process all definitions without raising errors.
+They make no assertions about specific holiday names, dates, or counts.
+
+## Purpose
+
+These tests are run from the upstream `holidays/definitions` repo's CI as the
+downstream check. The contract is narrow on purpose: a definitions change should
+only fail this suite if it actually breaks the gem's ability to load or process
+definitions, never because of intentional content changes (renaming a holiday,
+adding a region, shifting a date, etc.).
+
+## What belongs here
+
+- Tests that exercise the gem's API surface (`Holidays.on`, `Holidays.between`,
+  flags like `:observed` and `:informal`) across all regions and assert only
+  that nothing raises.
+- Tests that verify the *shape* of return values (e.g. `available_regions` is
+  an Array of Symbols).
+- Cross-region invariants that hold regardless of content (e.g. `:any` count is
+  ≥ each individual region's count).
+
+## What does NOT belong here
+
+- Any assertion about a specific holiday name, date, or count.
+- Any check that depends on the contents of a particular region's YAML.
+
+If a check would fail when someone legitimately renames "Labour Day" to
+"Labor Day" in `ca.yaml`, it does not belong in `smoke/`. It belongs in `e2e/`.

data/test/{integration → smoke}/test_available_regions.rb

@@ -15,9 +15,4 @@ class AvailableRegionsTests < Test::Unit::TestCase
     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 286, Holidays.available_regions.count
-  end
 end

data/test/smoke/test_smoke.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+class SmokeTests < Test::Unit::TestCase
+  SAMPLE_DATES = [
+    Date.civil(2023, 1, 1),
+    Date.civil(2023, 7, 4),
+    Date.civil(2023, 12, 25),
+  ]
+
+  def setup
+    Holidays.load_all
+    @regions = Holidays.available_regions
+  end
+
+  def test_all_regions_load_without_error
+    assert @regions.is_a?(Array)
+    assert @regions.count > 0
+    assert @regions.all? { |r| r.is_a?(Symbol) }
+  end
+
+  def test_holidays_on_does_not_raise_for_any_region
+    @regions.each do |region|
+      SAMPLE_DATES.each do |date|
+        assert_nothing_raised("Holidays.on raised for :#{region} on #{date}") do
+          result = Holidays.on(date, region)
+          assert result.is_a?(Array)
+        end
+      end
+    end
+  end
+
+  def test_holidays_between_does_not_raise_for_any_region
+    start_date = Date.civil(2023, 1, 1)
+    end_date = Date.civil(2023, 12, 31)
+
+    @regions.each do |region|
+      assert_nothing_raised("Holidays.between raised for :#{region}") do
+        result = Holidays.between(start_date, end_date, region)
+        assert result.is_a?(Array)
+      end
+    end
+  end
+
+  def test_observed_flag_does_not_raise_for_any_region
+    @regions.each do |region|
+      SAMPLE_DATES.each do |date|
+        assert_nothing_raised("Holidays.on with :observed raised for :#{region} on #{date}") do
+          Holidays.on(date, region, :observed)
+        end
+      end
+    end
+  end
+
+  def test_informal_flag_does_not_raise_for_any_region
+    @regions.each do |region|
+      SAMPLE_DATES.each do |date|
+        assert_nothing_raised("Holidays.on with :informal raised for :#{region} on #{date}") do
+          Holidays.on(date, region, :informal)
+        end
+      end
+    end
+  end
+
+  def test_any_region_count_meets_or_exceeds_each_individual_region
+    start_date = Date.civil(2023, 1, 1)
+    end_date = Date.civil(2023, 12, 31)
+    any_count = Holidays.between(start_date, end_date, :any).count
+
+    @regions.each do |region|
+      region_count = Holidays.between(start_date, end_date, region).count
+      assert any_count >= region_count, ":any count (#{any_count}) is less than :#{region} count (#{region_count})"
+    end
+  end
+end