revised_holidays 9.0.0

data/test/holidays/definition/repository/test_cache.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/definition/repository/cache'
+
+class CacheRepoTests < Test::Unit::TestCase
+  def setup
+    @subject = Holidays::Definition::Repository::Cache.new
+  end
+
+  def test_find_supports_overlapping_holidays
+    start_date = Date.civil(2015, 1, 1)
+    end_date = Date.civil(2015, 7, 1)
+    cache_data = [
+      {:date=>Date.civil(2015, 1, 1), :name=>"New Year's Day A", :regions=>[:us]},
+      {:date=>Date.civil(2015, 1, 1), :name=>"New Year's Day B", :regions=>[:us]}
+    ]
+    options = :us
+
+    @subject.cache_between(start_date, end_date, cache_data, options)
+
+    assert_equal(cache_data, @subject.find(start_date, start_date, options))
+    assert_equal(cache_data, @subject.find(start_date, end_date, options))
+  end
+
+  def test_cache_returns_empty_array_no_holidays_are_found
+    start_date = Date.civil(2015, 1, 1)
+    end_date = Date.civil(2015, 7, 1)
+    cache_data = [{:date=>Date.civil(2015, 1, 1), :name=>"New Year's Day", :regions=>[:us]}]
+    options = :us
+
+    @subject.cache_between(start_date, end_date, cache_data, options)
+
+    assert_empty(@subject.find(Date.civil(2015, 1, 2), Date.civil(2015, 1, 2), options))
+    assert_empty(@subject.find(Date.civil(2015, 1, 2), Date.civil(2015, 1, 3), options))
+  end
+
+  def test_cache_returns_empty_array_when_cache_is_empty
+    start_date = Date.civil(2015, 1, 1)
+    end_date = Date.civil(2015, 7, 1)
+    cache_data = []
+    options = :us
+
+    @subject.cache_between(start_date, end_date, cache_data, options)
+
+    assert_empty(@subject.find(Date.civil(2015, 1, 2), Date.civil(2015, 1, 2), options))
+    assert_empty(@subject.find(Date.civil(2015, 1, 2), Date.civil(2015, 1, 3), options))
+  end
+
+  def test_find_returns_correct_cache_data
+    start_date = Date.civil(2015, 1, 1)
+    end_date = Date.civil(2015, 7, 1)
+    cache_data = [{:date=>Date.civil(2015, 1, 1), :name=>"New Year's Day", :regions=>[:us]}]
+    options = :us
+    @subject.cache_between(start_date, end_date, cache_data, options)
+
+    assert_equal(cache_data, @subject.find(start_date, start_date, options))
+    assert_equal(cache_data, @subject.find(start_date, end_date, options))
+  end
+
+  def test_find_returns_nil_if_no_match_is_found
+    start_date = Date.civil(2015, 1, 1)
+    end_date = Date.civil(2015, 1, 1)
+    cache_data = [{:date=>Date.civil(2015, 1, 1), :name=>"New Year's Day", :regions=>[:us]}]
+    options = :us
+    @subject.cache_between(start_date, end_date, cache_data, options)
+
+    assert_nil(@subject.find(Date.civil(2015, 7, 1), Date.civil(2015, 12, 1), options))
+    assert_nil(@subject.find(Date.civil(2015, 7, 1), Date.civil(2015, 12, 1), options))
+  end
+
+  def test_cache_between_returns_error_if_dates_are_missing
+    start_date = Date.civil(2015, 1, 1)
+    end_date = Date.civil(2015, 1, 1)
+    cache_data = [{:date=>Date.civil(2015, 1, 1), :name=>"New Year's Day", :regions=>[:us]}]
+    options = :us
+
+    assert_raise ArgumentError do
+      @subject.cache_between(nil, end_date, cache_data, options)
+    end
+
+    assert_raise ArgumentError do
+      @subject.cache_between(start_date, nil, cache_data, options)
+    end
+  end
+
+  def test_cache_between_returns_error_if_dates_are_invalid
+    start_date = Date.civil(2015, 1, 1)
+    end_date = Date.civil(2015, 1, 1)
+    cache_data = [{:date=>Date.civil(2015, 1, 1), :name=>"New Year's Day", :regions=>[:us]}]
+    options = :us
+
+    assert_raise ArgumentError do
+      @subject.cache_between("invalid-date", end_date, cache_data, options)
+    end
+
+    assert_raise ArgumentError do
+      @subject.cache_between(start_date, "invalid-date", cache_data, options)
+    end
+  end
+
+  def test_cache_between_returns_error_if_cached_data_is_not_present
+    start_date = Date.civil(2015, 1, 1)
+    end_date = Date.civil(2015, 1, 1)
+    options = :us
+
+    assert_raise ArgumentError do
+      @subject.cache_between(start_date, end_date, nil, options)
+    end
+  end
+
+  def test_reset_clears_cache
+    start_date = Date.civil(2015, 1, 1)
+    end_date = Date.civil(2015, 1, 1)
+    cache_data = [{:date=>Date.civil(2015, 1, 1), :name=>"New Year's Day", :regions=>[:us]}]
+    options = :us
+    @subject.cache_between(start_date, end_date, cache_data, options)
+
+    assert_equal(cache_data, @subject.find(start_date, end_date, options))
+
+    @subject.reset!
+    assert_nil(@subject.find(start_date, end_date, options))
+  end
+end

data/test/holidays/definition/repository/test_custom_methods.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/definition/repository/custom_methods'
+
+class CustomMethodsRepoTests < Test::Unit::TestCase
+  def setup
+    @subject = Holidays::Definition::Repository::CustomMethods.new
+  end
+
+  def test_add_raises_error_if_input_is_nil
+    assert_raise ArgumentError do
+      @subject.add(nil)
+    end
+  end
+
+  def test_find_returns_nil_if_method_id_does_not_exist
+    assert_nil @subject.find("some-method-id")
+  end
+
+  def test_add_successfully_adds_new_custom_methods
+    new_custom_methods = {
+      "some-method-id" => Proc.new { |year|
+        Date.civil(year, 1, 1)
+      }
+    }
+
+    @subject.add(new_custom_methods)
+
+    target_method = @subject.find("some-method-id")
+
+    assert_equal new_custom_methods["some-method-id"], target_method
+  end
+
+  def test_find_raises_error_if_target_method_id_is_nil_or_empty
+    assert_raise ArgumentError do
+      @subject.find(nil)
+    end
+
+    assert_raise ArgumentError do
+      @subject.find("")
+    end
+  end
+end

data/test/holidays/definition/repository/test_holidays_by_month.rb

@@ -0,0 +1,275 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/definition/repository/holidays_by_month'
+
+class HolidaysByMonthRepoTests < Test::Unit::TestCase
+  def setup
+    @existing_holidays_by_month = {0 => [:mday => 1, :name => "Test", :regions => [:test]]}
+
+    @subject = Holidays::Definition::Repository::HolidaysByMonth.new
+  end
+
+  def test_all_returns_empty_hash_if_no_holidays_have_been_added
+    assert_equal({}, @subject.all)
+  end
+
+  def test_all_returns_existing_holidays
+    @subject.add(@existing_holidays_by_month)
+    assert_equal(@existing_holidays_by_month, @subject.all)
+  end
+
+  def test_add_does_not_change_data_if_it_already_exists
+    target_holidays = {0 => [:mday => 1, :name => "Test", :regions => [:test]]}
+
+    @subject.add(@existing_holidays_by_month)
+    @subject.add(target_holidays)
+
+    expected = @existing_holidays_by_month
+
+    assert_equal(expected, @subject.all)
+  end
+
+  def test_add_is_successful_if_name_is_different
+    target_holidays = {0 => [:mday => 1, :name => "Different", :regions => [:test]]}
+
+    @subject.add(@existing_holidays_by_month)
+    @subject.add(target_holidays)
+
+    expected = {
+                 0 => [
+                        {:mday=>1, :name=>"Test", :regions=>[:test]},
+                        {:mday=>1, :name=>"Different", :regions=>[:test]}
+                      ]
+                }
+
+    assert_equal(expected, @subject.all)
+  end
+
+  def test_add_is_successful_if_wday_is_different
+    target_holidays = {0 => [:mday => 1, :name => "Test", :wday => 1, :regions => [:test]]}
+
+    @subject.add(@existing_holidays_by_month)
+    @subject.add(target_holidays)
+
+    expected = {
+                 0 => [
+                        {:mday=>1, :name=>"Test", :regions=>[:test]},
+                        {:mday=>1, :name=>"Test", :wday => 1, :regions=>[:test]}
+                      ]
+                }
+
+    assert_equal(expected, @subject.all)
+  end
+
+  def test_add_is_successful_if_mday_is_different
+    target_holidays = {0 => [:mday => 2, :name => "Test", :regions => [:test]]}
+
+    @subject.add(@existing_holidays_by_month)
+    @subject.add(target_holidays)
+
+    expected = {
+                 0 => [
+                        {:mday=>1, :name=>"Test", :regions=>[:test]},
+                        {:mday=>2, :name=>"Test", :regions=>[:test]}
+                      ]
+                }
+
+    assert_equal(expected, @subject.all)
+  end
+
+  def test_add_is_successful_if_week_is_different
+    target_holidays = {0 => [:mday => 1, :name => "Test", :week => :first, :regions => [:test]]}
+
+    @subject.add(@existing_holidays_by_month)
+    @subject.add(target_holidays)
+
+    expected = {
+                 0 => [
+                        {:mday=>1, :name=>"Test", :regions=>[:test]},
+                        {:mday=>1, :name=>"Test", :week => :first, :regions=>[:test]}
+                      ]
+                }
+
+    assert_equal(expected, @subject.all)
+  end
+
+  def test_add_is_successful_if_type_is_different
+    target_holidays = {0 => [:mday => 1, :name => "Test", :type => :informal, :regions => [:test]]}
+
+    @subject.add(@existing_holidays_by_month)
+    @subject.add(target_holidays)
+
+    expected = {
+                 0 => [
+                        {:mday=>1, :name=>"Test", :regions=>[:test]},
+                        {:mday=>1, :name=>"Test", :type => :informal, :regions=>[:test]}
+                      ]
+                }
+
+    assert_equal(expected, @subject.all)
+  end
+
+  def test_add_is_successful_if_only_region_is_different_and_updates_regions_to_existing_matching_definitions
+    target_holidays = {0 => [:mday => 1, :name => "Test", :regions => [:test2]]}
+
+    @subject.add(@existing_holidays_by_month)
+    @subject.add(target_holidays)
+
+    expected = { 0 => [ {:mday=>1, :name=>"Test", :regions=>[:test, :test2]} ] }
+
+    assert_equal(expected, @subject.all)
+  end
+
+  def test_add_is_successful_and_updates_regions_to_existing_matching_definitions_and_deduped_correctly
+    target_holidays = {0 => [:mday => 1, :name => "Test", :regions => [:test2, :test]]}
+
+    @subject.add(@existing_holidays_by_month)
+    @subject.add(target_holidays)
+
+    expected = { 0 => [ {:mday=>1, :name=>"Test", :regions=>[:test, :test2]} ] }
+
+    assert_equal(expected, @subject.all)
+  end
+
+  def test_find_by_month_returns_nil_if_none_found
+    @subject.add(@existing_holidays_by_month)
+
+    holidays_for_month = @subject.find_by_month(12)
+    assert_equal(nil, holidays_for_month)
+  end
+
+  def test_find_by_month_returns_array_if_found
+    @subject.add(@existing_holidays_by_month)
+
+    holidays_for_month = @subject.find_by_month(0)
+    assert_equal(@existing_holidays_by_month[0], holidays_for_month)
+  end
+
+  def test_find_by_month_raises_error_if_month_is_not_valid
+    @subject.add(@existing_holidays_by_month)
+
+    assert_raise ArgumentError do
+      @subject.find_by_month(-1)
+    end
+  end
+
+  def test_add_is_successful_if_only_function_is_different
+    initial_holidays = {0=> [{:mday => 1, :name=>"Test", :regions=>[:test], :function=>"easter(year)", :function_arguments=>[:year]}]}
+
+    @subject.add(initial_holidays)
+
+    second_holidays = {0=> [{:mday => 1, :name=>"Test", :regions=>[:test2], :function=>"orthodox_easter(year)", :function_arguments=>[:year]}]}
+    @subject.add(second_holidays)
+
+    expected = {
+      0 => [
+        {
+          :function=>"easter(year)",
+          :function_arguments=>[:year],
+          :mday=>1,
+          :name=>"Test",
+          :regions=>[:test]
+        },
+        {
+          :function=>"orthodox_easter(year)",
+          :function_arguments=>[:year],
+          :mday=>1,
+          :name=>"Test",
+          :regions=>[:test2]
+        }
+      ]
+    }
+
+    assert_equal(expected, @subject.all)
+  end
+
+  def test_add_is_successful_if_only_function_modifier_is_different
+    initial_holidays = {0=> [{:mday => 1, :name=>"Test", :regions=>[:test], :function=>"easter(year)", :function_modifier=>1, :function_arguments=>[:year]}]}
+
+    @subject.add(initial_holidays)
+
+    second_holidays = {0=> [{:mday => 1, :name=>"Test", :regions=>[:test2], :function=>"easter(year)", :function_modifier=>2, :function_arguments=>[:year]}]}
+    @subject.add(second_holidays)
+
+    expected = {
+      0 => [
+        {
+          :function=>"easter(year)",
+          :function_arguments=>[:year],
+          :function_modifier=>1,
+          :mday=>1,
+          :name=>"Test",
+          :regions=>[:test]
+        },
+        {
+          :function=>"easter(year)",
+          :function_arguments=>[:year],
+          :function_modifier=>2,
+          :mday=>1,
+          :name=>"Test",
+          :regions=>[:test2]
+        }
+      ]
+    }
+
+    assert_equal(expected, @subject.all)
+  end
+
+  def test_add_is_successful_if_only_observed_is_different
+    initial_holidays = {0=> [{:mday => 1, :name=>"Test", :regions=>[:test], :observed=>"to_weekday_if_weekend(year)", :function_arguments=>[:year]}]}
+
+    @subject.add(initial_holidays)
+
+    second_holidays = {0=> [{:mday => 1, :name=>"Test", :regions=>[:test2], :observed =>"to_friday_if_saturday(year)", :function_arguments=>[:year]}]}
+    @subject.add(second_holidays)
+
+    expected = {
+      0 => [
+        {
+          :observed =>"to_weekday_if_weekend(year)",
+          :function_arguments=>[:year],
+          :mday=>1,
+          :name=>"Test",
+          :regions=>[:test]
+        },
+        {
+          :observed =>"to_friday_if_saturday(year)",
+          :function_arguments=>[:year],
+          :mday=>1,
+          :name=>"Test",
+          :regions=>[:test2]
+        }
+      ]
+    }
+
+    assert_equal(expected, @subject.all)
+  end
+
+  def test_add_is_successful_if_only_year_ranges_is_different
+    initial_holidays = {0=> [{:mday => 1, :name=>"Test", :regions=>[:test], :year_ranges => {:from => 1990}}]}
+
+    @subject.add(initial_holidays)
+
+    second_holidays = {0=> [{:mday => 1, :name=>"Test", :regions=>[:test2], :year_ranges => {:until => 2002}}]}
+    @subject.add(second_holidays)
+
+    expected = {
+      0 => [
+        {
+          :mday=>1,
+          :name=>"Test",
+          :regions=>[:test],
+          :year_ranges => {:from => 1990}
+        },
+        {
+          :mday=>1,
+          :name=>"Test",
+          :regions=>[:test2],
+          :year_ranges => {:until => 2002}
+        }
+      ]
+    }
+
+    assert_equal(expected, @subject.all)
+  end
+end

data/test/holidays/definition/repository/test_proc_result_cache.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/definition/repository/proc_result_cache'
+
+class ProcResultCacheRepoTests < Test::Unit::TestCase
+  def setup
+    @subject = Holidays::Definition::Repository::ProcResultCache.new
+  end
+
+  def test_lookup_stores_and_returns_result_of_function_if_it_is_not_present
+    function = lambda { |year| Date.civil(year, 2, 1) - 1 }
+    function_argument = 2015
+
+    assert_equal(Date.civil(2015, 1, 31), @subject.lookup(function, function_argument))
+  end
+
+  #FIXME This test stinks. I don't know how to show that the second invocation
+  #      doesn't call the function. In rspec I could just do an expect().not_to
+  #      but it doesn't seem like Mocha can do that? I'm punting.
+  def test_lookup_simply_returns_result_of_cache_if_present_after_first_call
+    function = lambda { |year| Date.civil(year, 2, 1) - 1 }
+    function_argument = 2015
+
+    assert_equal(Date.civil(2015, 1, 31), @subject.lookup(function, function_argument))
+  end
+
+  def test_lookup_raises_error_if_function_is_not_a_proc
+    function = "Holidays.easter(year)"
+    function_argument = 2015
+
+    assert_raise ArgumentError do
+      @subject.lookup(function, function_argument)
+    end
+  end
+
+  def test_lookup_accepts_date_as_function_argument
+    function = lambda { |date| date - 1 }
+    function_argument = Date.civil(2015, 2, 1)
+
+    assert_equal(Date.civil(2015, 1, 31), @subject.lookup(function, function_argument))
+  end
+
+  def test_lookup_accepts_symbol_as_function_argument
+    function = lambda { |symbol| symbol }
+    function_argument = :test
+
+    assert_equal(:test, @subject.lookup(function, function_argument))
+  end
+
+  def test_accepts_multiple_arguments_for_functions
+    function = lambda { |year, month, day| Date.civil(year, month, day) + 1 }
+    year = 2016
+    month = 1
+    day = 1
+
+    assert_equal(Date.civil(2016, 1, 2), @subject.lookup(function, year, month, day))
+  end
+
+  def test_raises_error_if_one_of_multiple_arguments_is_not_an_int_or_date
+    function = lambda { |year, month, day| Date.civil(year, month, day) + 1 }
+    year = 2016
+    month = 1
+    day = "1"
+
+    assert_raise ArgumentError do
+     @subject.lookup(function, year, month, day)
+    end
+  end
+
+  def test_accepts_mix_of_integers_and_dates_for_multiple_function_arguments
+    function = lambda { |date, modifier| date + modifier }
+    date = Date.civil(2016, 1, 1)
+    modifier = 5
+
+    assert_equal(Date.civil(2016, 1, 6), @subject.lookup(function, date, modifier))
+  end
+
+  def test_lookup_raises_error_if_function_argument_is_not_valid
+    function = lambda { |year| Date.civil(year, 2, 1) - 1 }
+    function_argument = "2015"
+
+    assert_raise ArgumentError do
+      @subject.lookup(function, function_argument)
+    end
+
+    function_argument = Proc.new { |arg1| "arg1" + "something"}
+    assert_raise ArgumentError do
+      @subject.lookup(function, function_argument)
+    end
+  end
+end

data/test/holidays/definition/repository/test_regions.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/definition/repository/regions'
+
+class RegionsRepoTests < Test::Unit::TestCase
+  def setup
+    @all_generated_regions = [:parent, :subregion, :subregion_with_underscores, :region1, :region2]
+    @parent_region_lookup = {
+      :subregion => :parent,
+      :subregion_with_underscores => :parent,
+    }
+
+    @subject = Holidays::Definition::Repository::Regions.new(@all_generated_regions, @parent_region_lookup)
+  end
+
+  def test_all_loaded_returns_an_empty_array_if_just_initialize
+    assert_equal([], @subject.all_loaded)
+  end
+
+  def test_add_successfully_adds_a_region
+    @subject.add(:test)
+    assert_equal([:test], @subject.all_loaded)
+  end
+
+  def test_add_raises_error_if_symbol_not_provided
+    assert_raises ArgumentError do
+      @subject.add('not-a-symbol')
+    end
+  end
+
+  def test_add_raises_error_if_argument_is_nil
+    assert_raises ArgumentError do
+      @subject.add(nil)
+    end
+  end
+
+  def test_add_raises_error_if_any_region_is_not_a_symbol
+    assert_raises ArgumentError do
+      @subject.add([:test, 'not-a-symbol'])
+    end
+  end
+
+  def test_add_does_not_add_if_the_region_already_exists
+    @subject.add(:test)
+    @subject.add(:test)
+    assert_equal([:test], @subject.all_loaded)
+  end
+
+  def test_add_accepts_array_of_regions
+    @subject.add([:test, :test2])
+    assert_equal([:test, :test2], @subject.all_loaded)
+  end
+
+  def test_exists_returns_true_if_region_is_present
+    @subject.add(:test)
+    assert @subject.loaded?(:test)
+  end
+
+  def tests_exists_returns_false_if_region_is_not_present
+    assert_equal(false, @subject.loaded?(:something))
+  end
+
+  def test_exists_raises_error_if_invalid_argument
+    assert_raises ArgumentError do
+      @subject.loaded?(nil)
+    end
+  end
+
+  def test_search_returns_empty_array_if_no_matches_found
+    assert_equal([], @subject.search(:something))
+  end
+
+  def test_search_returns_matches_on_prefix
+    @subject.add([:another_region, :test_region])
+    assert_equal([:test_region], @subject.search(:test_))
+  end
+
+  def test_search_returns_multiple_matches_on_prefix
+    @subject.add([:another_region, :test_region, :test_region2])
+    assert_equal([:test_region, :test_region2], @subject.search(:test_))
+  end
+
+  def test_search_raises_error_if_prefix_is_not_a_string
+    assert_raises ArgumentError do
+      @subject.search("string")
+    end
+
+    assert_raises ArgumentError do
+      @subject.search(nil)
+    end
+  end
+
+  def test_all_generated_returns_value_from_initializer
+    assert_equal(@all_generated_regions, @subject.all_generated)
+  end
+
+  def test_parent_region_lookup_returns_region_if_it_exists
+    assert_equal(@parent_region_lookup[:subregion], @subject.parent_region_lookup(:subregion))
+  end
+
+  def test_parent_region_lookup_returns_nil_if_does_not_exist_in_lookup
+    assert_nil(@subject.parent_region_lookup(:parent))
+  end
+end