holidays 4.6.0 → 4.7.0

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

@@ -0,0 +1,38 @@
+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_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

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

@@ -0,0 +1,170 @@
+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_contains_only_empty_hashes
+    @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_before_operator_and_value_is_not_a_number
+    @year_ranges = [{before: "bad"}]
+    assert_raises ArgumentError do
+      @subject.call(@year, @year_ranges)
+    end
+  end
+
+  def test_returns_true_if_before_operator_and_target_is_before
+    @year_ranges = [{before: 2000}]
+    assert_equal(true, @subject.call(1999, @year_ranges))
+  end
+
+  def test_returns_true_if_before_operator_and_target_is_equal
+    @year_ranges = [{before: 2000}]
+    assert_equal(true, @subject.call(2000, @year_ranges))
+  end
+
+  def test_returns_false_if_before_operator_and_target_is_after
+    @year_ranges = [{before: 2000}]
+    assert_equal(false, @subject.call(2001, @year_ranges))
+  end
+
+  def test_returns_error_if_after_operator_with_bad_value
+    @year_ranges = [{after: "bad"}]
+    assert_raises ArgumentError do
+      @subject.call(@year, @year_ranges)
+    end
+  end
+
+  def test_returns_false_if_after_operator_and_target_is_before
+    @year_ranges = [{after: 2000}]
+    assert_equal(false, @subject.call(1999, @year_ranges))
+  end
+
+  def test_returns_true_if_after_operator_and_target_is_equal
+    @year_ranges = [{after: 2000}]
+    assert_equal(true, @subject.call(2000, @year_ranges))
+  end
+
+  def test_returns_true_if_after_operator_and_target_is_after
+    @year_ranges = [{after: 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_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
+
+  def test_returns_false_multiple_nonmatching_operators
+    @year_ranges = [{between: 1998..2002}, {:after => 2005}]
+    assert_equal(false, @subject.call(2003, @year_ranges))
+
+    @year_ranges = [{before: 1995}, {:limited => [1990, 1991, 1992]}]
+    assert_equal(false, @subject.call(1996, @year_ranges))
+  end
+
+  def test_returns_true_multiple_operators_all_matching
+    @year_ranges = [{between: 1998..2002}, {:limited=> [2000, 2001]}]
+    assert_equal(true, @subject.call(2001, @year_ranges))
+  end
+
+  def test_returns_true_if_multiple_operators_and_only_one_matches
+    @year_ranges = [{before: 2015}, {:after=> 2017}]
+    assert_equal(true, @subject.call(2001, @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 defintions 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/{test_all_regions.rb → integration/test_all_regions.rb}

@@ -1,6 +1,6 @@
-require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
 
-class MultipleRegionsTests < Test::Unit::TestCase
+class AllRegionsTests < Test::Unit::TestCase
   def setup
     Holidays::LoadAllDefinitions.call
   end
@@ -19,12 +19,26 @@ class MultipleRegionsTests < Test::Unit::TestCase
   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::UnknownRegionError do
       Holidays.on(Date.civil(2014, 1, 1), :something_we_do_not_recognize)
     end
+
+    assert_raise Holidays::UnknownRegionError do
+      Holidays.on(Date.civil(2020, 1, 1), :something_we_do_not_recognize)
+    end
+
+    assert_raise Holidays::UnknownRegionError do
+      Holidays.on(Date.civil(2030, 1, 1), :something_we_do_not_recognize)
+    end
   end
 
   def test_malicious_load_attempt_raises_exception

data/test/{test_custom_holidays.rb → integration/test_custom_holidays.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
 
 class CustomHolidaysTest < Test::Unit::TestCase
 
@@ -7,7 +7,7 @@ class CustomHolidaysTest < Test::Unit::TestCase
       Holidays.on(Date.civil(2013,6,20), :custom_single_file)
     end
 
-    loaded_holidays = Holidays.load_custom('test/data/test_single_custom_holiday_defs.yaml')
+    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

data/test/{test_custom_year_range_holidays.rb → integration/test_custom_year_range_holidays.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
 
 class CustomYearRangeHolidaysTest < Test::Unit::TestCase
 

data/test/{test_holidays.rb → integration/test_holidays.rb}

@@ -1,5 +1,5 @@
 # encoding: utf-8
-require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
 
 require "#{Holidays::DEFINITIONS_PATH}/ca"
 
@@ -7,8 +7,6 @@ require "#{Holidays::DEFINITIONS_PATH}/ca"
 # defs aren't duplicated.
 require "#{Holidays::DEFINITIONS_PATH}/north_america"
 
-# These are effectively integration tests. We plan on making this explicit somehow
-# in the future.
 class HolidaysTests < Test::Unit::TestCase
   def setup
     @date = Date.civil(2008,1,1)
@@ -115,10 +113,7 @@ class HolidaysTests < Test::Unit::TestCase
     assert_equal ['2008-05-19','Victoria Day'] , [holidays.first[:date].to_s, holidays.first[:name].to_s]
 
     # Should return 2 holidays.
-    #
-    # Should be 2 in the CA region but other regional files are loaded during the
-    # unit tests add to the :any count.
-    holidays = Holidays.next_holidays(2, [:any], Date.civil(2008,5,1))
+    holidays = Holidays.next_holidays(2, [:ca], Date.civil(2008,5,1))
     assert_equal 2, holidays.length
 
     # Should return 1 holiday in July
@@ -140,59 +135,77 @@ class HolidaysTests < Test::Unit::TestCase
   end
 
   def test_year_holidays
-    # Should return 10 holidays from February 23 to December 31
+    # Should return 9 holidays from February 23 to December 31
     holidays = Holidays.year_holidays([:ca_on], Date.civil(2016, 2, 23))
-    assert_equal 10, holidays.length
+    assert_equal 9, holidays.length
 
     # Must have options (Regions)
-    assert_raises ArgumentError do 
+    assert_raises ArgumentError do
       Holidays.year_holidays([], Date.civil(2016, 2, 23))
-    end 
+    end
 
-    # Options must be in the form of an array.  
-    assert_raises ArgumentError do 
+    # 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 
+    end
+  end
 
   def test_year_holidays_with_specified_year
-    # Should return all 12 holidays for 2016 in Ontario, Canada
+    # Should return all 11 holidays for 2016 in Ontario, Canada
     holidays = Holidays.year_holidays([:ca_on], Date.civil(2016, 1, 1))
-    assert_equal 12, holidays.length
+    assert_equal 11, holidays.length
 
-    # Should return all 12 holidays for 2016 in Australia
+    # 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 
+  end
 
-  def test_year_holidays_without_specified_year 
+  def test_year_holidays_without_specified_year
     # Gets holidays for current year from today's date
     holidays = Holidays.year_holidays([:ca_on])
     assert_equal holidays.first[:date].year, Date.today.year
-  end 
+  end
 
   def test_year_holidays_feb_29_on_non_leap_year
-    # Should throw argument error for invalid date
-    assert_raises ArgumentError do 
+    assert_raises ArgumentError do
       Holidays.year_holidays([:ca_on], Date.civil(2015, 2, 29))
     end
-  end 
+
+    assert_raises ArgumentError do
+      Holidays.year_holidays([:ca_on], Date.civil(2019, 2, 29))
+    end
+
+    assert_raises ArgumentError do
+      Holidays.year_holidays([:ca_on], Date.civil(2021, 2, 29))
+    end
+
+    assert_raises ArgumentError do
+      Holidays.year_holidays([:us], Date.civil(2023, 2, 29))
+    end
+
+    assert_raises ArgumentError do
+      Holidays.year_holidays([:ca_on], Date.civil(2025, 2, 29))
+    end
+  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 11, holidays.length
+    assert_equal 10, holidays.length
 
     # Family day still didn't exist in 2000
     holidays = Holidays.year_holidays([:ca_on], Date.civil(2000, 1, 1))
-    assert_equal 11, holidays.length
+    assert_equal 10, holidays.length
 
     holidays = Holidays.year_holidays([:ca_on], Date.civil(2020, 1, 1))
-    assert_equal 12, holidays.length
+    assert_equal 11, holidays.length
 
     holidays = Holidays.year_holidays([:ca_on], Date.civil(2050, 1, 1))
-    assert_equal 12, holidays.length
-  end 
+    assert_equal 11, holidays.length
+
+    holidays = Holidays.year_holidays([:jp], Date.civil(2070, 1, 1))
+    assert_equal 18, holidays.length
+  end
 
   def test_sub_regions
     # Should return Victoria Day.
@@ -250,15 +263,13 @@ class HolidaysTests < Test::Unit::TestCase
     }
   end
 
-  #FIXME - I am not a huge fan of this test as it is written. It depends on the definitions not changing.
-  #        I think that this is fine for an integration test but I think it should be labeled as such.
   def test_caching
     start_date = Date.civil(2008, 3, 21)
     end_date = Date.civil(2008, 3, 25)
     cache_data = Holidays.between(start_date, end_date, :ca, :informal)
     options = [:ca, :informal]
 
-    Holidays::DefinitionFactory.cache_repository.expects(:cache_between).with(start_date, end_date, cache_data, options)
+    Holidays::Factory::Definition.cache_repository.expects(:cache_between).with(start_date, end_date, cache_data, options)
 
     Holidays.cache_between(Date.civil(2008,3,21), Date.civil(2008,3,25), :ca, :informal)
 

data/test/{test_holidays_between.rb → integration/test_holidays_between.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
 
 require "#{Holidays::DEFINITIONS_PATH}/ca"
 
@@ -10,14 +10,14 @@ require "#{Holidays::DEFINITIONS_PATH}/ca"
 # and don't want to bite off more than I can chew.
 require "#{Holidays::DEFINITIONS_PATH}/north_america"
 
-class HolidaysTests < Test::Unit::TestCase
+class HolidaysBetweenTests < Test::Unit::TestCase
   def setup
     @date = Date.civil(2008,1,1)
     @subject = Holidays.method(:between)
   end
 
   def teardown
-    Holidays::DefinitionFactory.cache_repository.reset!
+    Holidays::Factory::Definition.cache_repository.reset!
   end
 
   def test_between
@@ -46,7 +46,7 @@ class HolidaysTests < Test::Unit::TestCase
     end_date = Date.civil(2015, 1, 31)
     options = [:us, :informal]
 
-    Holidays::DefinitionFactory.cache_repository.expects(:find).with(start_date, end_date, options).returns({cached: 'data'})
+    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
@@ -56,13 +56,9 @@ class HolidaysTests < Test::Unit::TestCase
     end_date = Date.civil(2015, 1, 31)
     options = [:us]
 
-    options_parser_mock = mock()
-    Holidays::OptionFactory.stubs(:parse_options).returns(options_parser_mock)
-    options_parser_mock.expects(:call).with(options).returns([[:us], false, false])
-
     between_mock = mock()
-    Holidays::UseCaseFactory.stubs(:between).returns(between_mock)
-    between_mock.expects(:call).with(start_date, end_date, {2015 => [0, 1, 2], 2014 => [0, 12]}, [:us], false, false)
+    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
@@ -72,13 +68,9 @@ class HolidaysTests < Test::Unit::TestCase
     end_date = Date.civil(2015, 1, 31)
     options = [:us]
 
-    dates_driver_builder_mock = mock()
-    Holidays::UseCaseFactory.stubs(:dates_driver_builder).returns(dates_driver_builder_mock)
-    dates_driver_builder_mock.expects(:call).with(start_date, end_date).returns({2015 => [0, 1, 2]})
-
     between_mock = mock()
-    Holidays::UseCaseFactory.stubs(:between).returns(between_mock)
-    between_mock.expects(:call).with(start_date, end_date, {2015 => [0, 1, 2]}, [:us], false, false)
+    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