revised_holidays 9.0.0

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

@@ -0,0 +1,141 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/finder/context/parse_options'
+
+class ParseOptionsTests < Test::Unit::TestCase
+  def setup
+    @regions_repo = mock()
+    @regions_repo.stubs(:loaded?).returns(false)
+
+    @region_validator = mock()
+    @region_validator.stubs(:valid?).returns(true)
+
+    @definition_loader = mock()
+    @definition_loader.stubs(:call)
+
+    @subject = Holidays::Finder::Context::ParseOptions.new(
+      @regions_repo,
+      @region_validator,
+      @definition_loader,
+    )
+  end
+
+  def test_returns_observed_true_if_options_contains_observed_flag
+    @regions_repo.expects(:parent_region_lookup).with(:ca).returns(:ca)
+    observed = @subject.call([:ca, :observed])[1]
+    assert_equal(true, observed)
+  end
+
+  def test_returns_observed_false_if_options_does_not_contain_observed_flag
+    @regions_repo.expects(:parent_region_lookup).with(:ca).returns(:ca)
+    observed = @subject.call([:ca])[1]
+    assert_equal(false, observed)
+  end
+
+  def test_returns_informal_true_if_options_contains_informal_flag
+    @regions_repo.expects(:parent_region_lookup).with(:ca).returns(:ca)
+    informal = @subject.call([:ca, :informal])[2]
+    assert_equal(true, informal)
+  end
+
+  def test_returns_informal_false_if_options_does_not_contain_informal_flag
+    @regions_repo.expects(:parent_region_lookup).with(:ca).returns(:ca)
+    informal = @subject.call([:ca])[2]
+    assert_equal(false, informal)
+  end
+
+  def test_raises_error_if_regions_are_invalid
+    @region_validator.stubs(:valid?).returns(false)
+
+    assert_raise Holidays::InvalidRegion do
+      @subject.call([:unknown_region])
+    end
+  end
+
+  def test_wildcards_load_appropriate_regions
+    @definition_loader.expects(:call).with(:ch).returns([:ch, :ch_zh])
+
+    regions = @subject.call([:ch_]).first
+
+    assert_equal([:ch, :ch_zh], regions)
+    assert_equal(false, regions.include?(:ch_))
+  end
+
+  def test_does_nothing_if_region_is_already_loaded_and_is_parent
+    @regions_repo.expects(:parent_region_lookup).with(:test).returns(nil)
+    regions = @subject.call([:test]).first
+    assert_equal([:test], regions)
+  end
+
+  def test_does_nothing_if_region_is_already_loaded_and_is_parent_but_is_custom
+    @regions_repo.expects(:parent_region_lookup).with(:custom_region).returns(nil)
+    @regions_repo.expects(:loaded?).with(:custom_region).returns(true)
+
+    regions = @subject.call([:custom_region]).first
+    assert_equal([:custom_region], regions)
+  end
+
+  def test_has_parent_loads_parent_region
+    @regions_repo.expects(:parent_region_lookup).with(:subregion).returns(:parent)
+    @regions_repo.expects(:loaded?).with(:parent).returns(false)
+    @definition_loader.expects(:call).with(:parent).returns([:parent, :subregion])
+
+    regions = @subject.call([:subregion]).first
+    assert_equal([:subregion], regions)
+  end
+
+  def test_has_parent_already_loaded_does_not_load_again
+    @regions_repo.expects(:parent_region_lookup).with(:subregion).returns(:parent)
+    @regions_repo.expects(:loaded?).with(:parent).returns(false)
+    @definition_loader.expects(:call).with(:parent).returns([:parent, :subregion])
+
+    regions = @subject.call([:subregion]).first
+    assert_equal([:subregion], regions)
+  end
+
+  def test_cannot_load_region_prefix_for_wildcard_raises_error
+    @definition_loader.expects(:call).with(:ch).raises(LoadError)
+    assert_raises Holidays::UnknownRegionError do
+      @subject.call([:ch_])
+    end
+  end
+
+  def test_cannot_load_region_not_wildcard_raises_error
+    @regions_repo.expects(:parent_region_lookup).with(:ch).returns(:ch)
+    @definition_loader.expects(:call).with(:ch).raises(LoadError)
+    assert_raises Holidays::UnknownRegionError do
+      @subject.call([:ch])
+    end
+  end
+
+  def test_region_with_multiple_underscores_load_correctly
+    @regions_repo.expects(:parent_region_lookup).with(:subregion_with_underscores).returns(:parent)
+    @regions_repo.expects(:loaded?).with(:parent).returns(false)
+    @definition_loader.expects(:call).with(:parent).returns([:parent, :subregion_with_underscores])
+
+    regions = @subject.call([:subregion_with_underscores]).first
+    assert_equal([:subregion_with_underscores], regions)
+  end
+
+  def test_blank_region_should_load_all_regions_available
+    @regions_repo.expects(:all_generated).returns([:region1, :region2])
+    @regions_repo.expects(:loaded?).with(:region1).returns(false)
+    @regions_repo.expects(:loaded?).with(:region2).returns(true)
+    @regions_repo.expects(:parent_region_lookup).with(:region1).returns(:region2)
+    @definition_loader.expects(:call).with(:region2)
+
+    regions = @subject.call.first
+    assert_equal([:region1, :region2], regions)
+  end
+
+  def test_special_any_region_should_load_all_regions_available
+    @regions_repo.expects(:all_generated).returns([:region1, :region2])
+    @regions_repo.expects(:loaded?).with(:region1).returns(false)
+    @regions_repo.expects(:loaded?).with(:region2).returns(true)
+    @regions_repo.expects(:parent_region_lookup).with(:region1).returns(:region2)
+    @definition_loader.expects(:call).with(:region2)
+
+    regions = @subject.call(:any).first
+    assert_equal([:region1, :region2], regions)
+  end
+end

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

@@ -0,0 +1,232 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/finder/context/search'
+
+class FinderSearchTests < Test::Unit::TestCase
+  def setup
+    @holidays_by_month_repo = mock()
+    @custom_method_processor = mock()
+    @day_of_month_calculator = mock()
+
+    @in_region_rule = mock()
+    @year_range_rule = mock()
+    @rules = {:in_region => @in_region_rule, :year_range => @year_range_rule}
+
+    @custom_method_repo = mock()
+    @proc_cache_repo = mock()
+
+    @start_date = Date.civil(2015, 1, 1)
+    @end_date = Date.civil(2015, 1, 1)
+    @dates_driver = {2015 => [1]}
+    @regions = [:us]
+    @options = []
+
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns([:mday => 1, :name => "Test", :regions=>@regions])
+    @in_region_rule.expects(:call).at_most_once.returns(true)
+    @year_range_rule.expects(:call).at_most_once.returns(false)
+
+    @subject = Holidays::Finder::Context::Search.new(
+      @holidays_by_month_repo,
+      @custom_method_processor,
+      @day_of_month_calculator,
+      @rules,
+    )
+  end
+
+  def test_raises_error_if_dates_driver_is_empty
+    @dates_driver = {}
+    assert_raises ArgumentError do
+      @subject.call(@dates_driver, @regions, @options)
+    end
+  end
+
+  def test_raises_error_if_dates_driver_contains_bad_month
+    @dates_driver = {2015 => [100]}
+    assert_raises ArgumentError do
+      @subject.call(@dates_driver, @regions, @options)
+    end
+  end
+
+  def test_raises_error_if_dates_driver_contains_bad_month_mixed_with_valid_months
+    @dates_driver = {2015 => [1, 12], 2020 => [1, 200]}
+    assert_raises ArgumentError do
+      @subject.call(@dates_driver, @regions, @options)
+    end
+  end
+
+  def test_returns_nothing_if_holidays_repo_returns_nil
+    @holidays_by_month_repo.expects(:find_by_month).with(1).returns(nil)
+    assert_equal([], @subject.call(@dates_driver, @regions, @options))
+  end
+
+  def test_returns_nothing_if_holidays_repo_returns_empty_array
+    @holidays_by_month_repo.expects(:find_by_month).with(1).returns([])
+    assert_equal([], @subject.call(@dates_driver, @regions, @options))
+  end
+
+  def test_returns_nothing_if_holidays_not_in_region
+    @holidays_by_month_repo.expects(:find_by_month).returns([:regions=>[:other_region]])
+    @in_region_rule.expects(:call).with(@regions, [:other_region]).returns(false)
+    assert_equal([], @subject.call(@dates_driver, @regions, @options))
+  end
+
+  def test_returns_nothing_if_only_informal_holidays_are_returned_and_no_informal_flag_set
+    @holidays_by_month_repo.expects(:find_by_month).returns([:type => :informal, :regions=>@regions])
+    assert_equal([], @subject.call(@dates_driver, @regions, @options))
+  end
+
+  def test_year_rule_set_but_not_in_required_years_returns_nothing
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns([:mday => 1, :name => "Test", :regions=>@regions, :year_ranges => [:after => 2000]])
+    assert_equal([], @subject.call(@dates_driver, @regions, @options))
+  end
+
+  def test_function_present_returns_date
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns([:mday => 1, :name => "Test", :regions=> @regions, :function => "func-id", :function_arguments => [:year], :function_modifier => 1])
+
+    returned_date = Date.civil(2015, 3, 10)
+    @custom_method_processor.expects(:call).with(
+      {:year => 2015, :month => 1, :day => 1, :region => :us},
+      "func-id",
+      [:year],
+      1,
+    ).returns(returned_date)
+
+    assert_equal(
+      [{
+        :date => Date.civil(2015, 3, 10),
+        :name => "Test",
+        :regions => [:us],
+      }],
+       @subject.call(@dates_driver, @regions, @options)
+    )
+  end
+
+  #FIXME This is a test that reflects how the current system works
+  #      but this is NOT valid. See https://github.com/holidays/holidays/issues/204
+  def test_function_returns_nil_date_should_not_be_returned
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns([:mday => 1, :name => "Test", :regions=> @regions, :function => "func-id", :function_arguments => [:year], :function_modifier => 1])
+
+    @custom_method_processor.expects(:call).with(
+      {:year => 2015, :month => 1, :day => 1, :region => :us},
+      "func-id",
+      [:year],
+      1,
+    ).returns(nil)
+
+    assert_equal([], @subject.call(@dates_driver, @regions, @options))
+  end
+
+  def test_function_not_present_mday_set
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns([:mday => 15, :name => "Test", :regions=> @regions])
+
+    assert_equal(
+      [{
+        :date => Date.civil(2015, 1, 15),
+        :name => "Test",
+        :regions => [:us],
+      }],
+       @subject.call(@dates_driver, @regions, @options)
+    )
+  end
+
+  def test_function_not_present_mday_not_set
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns([:name => "Test", :week => 1, :wday => 1, :regions=> @regions])
+
+    @day_of_month_calculator.expects(:call).with(2015, 1, 1, 1).returns(20)
+
+    assert_equal(
+      [{
+        :date => Date.civil(2015, 1, 20),
+        :name => "Test",
+        :regions => [:us],
+      }],
+      @subject.call(@dates_driver, @regions, @options)
+    )
+  end
+
+  def test_returns_holiday_if_informal_and_informal_flag_set
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns([:mday => 13, :name => "Test", :type => :informal, :regions=>@regions])
+
+    assert_equal(
+      [{
+        :date => Date.civil(2015, 1, 13),
+        :name => "Test",
+        :regions => [:us],
+      }],
+      @subject.call(@dates_driver, @regions, [:informal])
+    )
+  end
+
+  def test_does_not_return_holiday_if_informal_and_informal_flag_not_set
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns([:mday => 13, :name => "Test", :type => :informal, :regions=>@regions])
+
+    assert_equal([], @subject.call(@dates_driver, @regions, @options))
+  end
+
+  def test_returns_observed_result_if_observed_set_and_observed_function_present
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns([:mday => 8, :name => "Test", :type => :observed, :observed => "SOME_OBSERVED_FUNC_ID", :regions=>@regions])
+
+    @custom_method_processor.expects(:call).with(
+      {:year => 2015, :month => 1, :day => 8, :region => :us},
+      "SOME_OBSERVED_FUNC_ID",
+      [:date],
+    ).returns(Date.civil(2015, 10, 1))
+
+    assert_equal(
+      [{
+        :date => Date.civil(2015, 10, 1),
+        :name => "Test",
+        :regions => [:us],
+      }],
+      @subject.call(@dates_driver, @regions, [:observed])
+    )
+  end
+
+  def test_returns_unobserved_date_if_observed_method_not_set_but_flag_is_present
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns([:mday => 14, :name => "Test", :type => :observed, :observed => "SOME_OBSERVED_FUNC_ID", :regions=>@regions])
+
+    assert_equal(
+      [{
+        :date => Date.civil(2015, 1, 14),
+        :name => "Test",
+        :regions => [:us],
+      }],
+      @subject.call(@dates_driver, @regions, @options)
+    )
+  end
+
+  # This is a specific scenario but it COULD happen in our current flow. The goal: any date
+  # manipulation that occurs for a specific holiday should have no impact on other holidays.
+  def test_returns_expected_result_if_custom_method_modifies_month_when_multiple_holidays_found
+    @in_region_rule.expects(:call).twice.returns(true)
+    @holidays_by_month_repo.expects(:find_by_month).at_most_once.returns(
+      [
+        {:mday => 14, :name => "Test", :function => "func-id", :function_arguments => [:year], :regions => @regions},
+        {:mday => 14, :name => "Test2", :regions => @regions},
+      ]
+    )
+
+    @custom_method_processor.expects(:call).with(
+      {:year => 2015, :month => 1, :day => 14, :region => :us},
+      "func-id",
+      [:year],
+      nil,
+    ).returns(Date.civil(2015, 3, 14))
+
+    assert_equal(
+      [
+        {
+          :date => Date.civil(2015, 3, 14),
+          :name => "Test",
+          :regions => [:us],
+        },
+        {
+          :date => Date.civil(2015, 1, 14),
+          :name => "Test2",
+          :regions => [:us],
+        }
+      ],
+      @subject.call(@dates_driver, @regions, @options)
+    )
+  end
+end

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

@@ -0,0 +1,202 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/finder/context/year_holiday'
+
+class YearHolidayTests < Test::Unit::TestCase
+  def setup
+    @regions = [:us]
+    @observed = false
+    @informal = false
+
+    @definition_search = mock()
+    @dates_driver_builder = mock()
+    @options_parser = mock()
+
+    @subject = Holidays::Finder::Context::YearHoliday.new(
+      @definition_search,
+      @dates_driver_builder,
+      @options_parser,
+    )
+
+    @from_date= Date.civil(2015, 1, 1)
+    @dates_driver = {2015 => [0, 1, 2], 2014 => [0, 12]}
+    @options = [@regions, @observed, @informal]
+
+    @definition_search.expects(:call).at_most_once.with(
+      @dates_driver,
+      @regions,
+      [],
+    ).returns([{
+      :date => Date.civil(2015, 1, 1),
+      :name => "Test",
+      :regions => [:us],
+    }])
+
+    @dates_driver_builder.expects(:call).at_most_once.with(
+      @from_date, @from_date >> 12,
+    ).returns(
+      @dates_driver,
+    )
+
+    @options_parser.expects(:call).at_most_once.with(@options).returns(@options)
+  end
+
+  def test_returns_error_if_from_date_is_missing
+    assert_raise ArgumentError do
+      @subject.call(nil, @options)
+    end
+  end
+
+  def test_returns_error_if_from_date_is_not_a_date
+    assert_raise ArgumentError do
+      @subject.call("2015-1-1", @options)
+    end
+  end
+
+  def test_returns_single_holiday
+    assert_equal(
+      [
+        {
+          :date => Date.civil(2015, 1, 1),
+          :name => "Test",
+          :regions => [:us],
+        }
+      ],
+      @subject.call(@from_date, @options)
+    )
+  end
+
+  def test_returns_multiple_holidays_in_a_year
+    @definition_search.expects(:call).at_most_once.with(
+      @dates_driver,
+      @regions,
+      [],
+    ).returns([
+      {
+        :date => Date.civil(2015, 1, 1),
+        :name => "Test",
+        :regions => [:us],
+      },
+      {
+        :date => Date.civil(2015, 2, 1),
+        :name => "Test",
+        :regions => [:us],
+      },
+      {
+        :date => Date.civil(2015, 12, 1),
+        :name => "Test",
+        :regions => [:us],
+      },
+      ]
+    )
+
+    assert_equal(
+      [
+        {
+          :date => Date.civil(2015, 1, 1),
+          :name => "Test",
+          :regions => [:us],
+        },
+        {
+          :date => Date.civil(2015, 2, 1),
+          :name => "Test",
+          :regions => [:us],
+        },
+        {
+          :date => Date.civil(2015, 12, 1),
+          :name => "Test",
+          :regions => [:us],
+        }
+      ],
+      @subject.call(@from_date, @options)
+    )
+  end
+
+  def test_returns_multiple_holidays_filters_dates_outside_of_year
+    @definition_search.expects(:call).at_most_once.with(
+      @dates_driver,
+      @regions,
+      [],
+    ).returns([
+      {
+        :date => Date.civil(2015, 1, 1),
+        :name => "Test",
+        :regions => [:us],
+      },
+      {
+        :date => Date.civil(2015, 2, 1),
+        :name => "Test",
+        :regions => [:us],
+      },
+      {
+        :date => Date.civil(2016, 12, 1),
+        :name => "Test",
+        :regions => [:us],
+      },
+      ]
+    )
+
+    assert_equal(
+      [
+        {
+          :date => Date.civil(2015, 1, 1),
+          :name => "Test",
+          :regions => [:us],
+        },
+        {
+          :date => Date.civil(2015, 2, 1),
+          :name => "Test",
+          :regions => [:us],
+        },
+      ],
+      @subject.call(@from_date, @options)
+    )
+  end
+
+  def test_returns_sorted_multiple_holidays
+    @definition_search.expects(:call).at_most_once.with(
+      @dates_driver,
+      @regions,
+      [],
+    ).returns(
+      [
+        {
+          :date => Date.civil(2015, 1, 1),
+          :name => "Test",
+          :regions => [:us],
+        },
+        {
+          :date => Date.civil(2015, 12, 1),
+          :name => "Test",
+          :regions => [:us],
+        },
+        {
+          :date => Date.civil(2015, 2, 1),
+          :name => "Test",
+          :regions => [:us],
+        },
+      ]
+    )
+
+    assert_equal(
+      [
+        {
+          :date => Date.civil(2015, 1, 1),
+          :name => "Test",
+          :regions => [:us],
+        },
+        {
+          :date => Date.civil(2015, 2, 1),
+          :name => "Test",
+          :regions => [:us],
+        },
+        {
+          :date => Date.civil(2015, 12, 1),
+          :name => "Test",
+          :regions => [:us],
+        }
+      ],
+      @subject.call(@from_date, @options)
+    )
+  end
+end

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

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/finder/rules/in_region'
+
+class FinderRulesInRegionTests < Test::Unit::TestCase
+  def setup
+    @available = [:test]
+    @subject = Holidays::Finder::Rules::InRegion
+  end
+
+  def test_returns_true_if_any_specified
+    assert_equal(true, @subject.call([:any], @available))
+  end
+
+  def test_returns_true_if_exact_match_found
+    assert_equal(true, @subject.call([:test], @available))
+  end
+
+  def test_returns_true_if_subregion_matches_parent
+    assert_equal(true, @subject.call([:test_sub], @available))
+  end
+  
+  def test_returns_true_if_subregion_matches_grandparent
+    assert_equal(true, @subject.call([:test_sub_sub], @available))
+  end
+
+  def test_returns_true_if_subregion_is_in_available
+    assert_equal(true, @subject.call([:test_sub], [:test, :test_sub]))
+  end
+
+  def test_returns_false_if_match_not_found
+    assert_equal(false, @subject.call([:other], @available))
+  end
+
+  def test_returns_false_if_match_not_found_for_subregion
+    assert_equal(false, @subject.call([:other_sub], @available))
+  end
+
+  def test_returns_true_if_request_includes_nonmatching_but_also_any
+    assert_equal(true, @subject.call([:other_sub, :other, :any], @available))
+  end
+end