holidays 3.3.0 → 4.0.0

data/test/holidays/definition/decorator/test_custom_method_source.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/definition/decorator/custom_method_source'
+require 'holidays/definition/entity/custom_method'
+
+class DecoratorCustomMethodSourceTests < Test::Unit::TestCase
+  def setup
+    @decorator = Holidays::Definition::Decorator::CustomMethodSource.new
+  end
+
+  def test_call_generates_source_from_entity
+    entity = Holidays::Definition::Entity::CustomMethod.new(
+      name: "test",
+      arguments: ["year"],
+      source: "Date.civil(year, 1, 1)"
+    )
+
+    source = @decorator.call(entity)
+    expected_source = "\"#{entity.name}(#{entity.arguments[0]})\" => Proc.new { |year|\n#{entity.source}}"
+
+    assert_equal expected_source, source
+  end
+
+  def test_call_generates_source_from_entity_with_multiple_arguments
+    entity = Holidays::Definition::Entity::CustomMethod.new(
+      name: "test",
+      arguments: ["year", "month"],
+      source: "Date.civil(year, month, 1)"
+    )
+
+    source = @decorator.call(entity)
+    expected_args = "#{entity.arguments[0]}, #{entity.arguments[1]}"
+
+    expected_source = "\"#{entity.name}(#{expected_args})\" => Proc.new { |#{expected_args}|\n#{entity.source}}"
+
+    assert_equal expected_source, source
+  end
+
+  def test_call_generates_source_from_entity_when_source_is_multiple_lines
+    entity = Holidays::Definition::Entity::CustomMethod.new(
+      name: "test",
+      arguments: ["year"],
+      source: "d = Date.civil(year, 1, 1)\nd + 2"
+    )
+
+    source = @decorator.call(entity)
+    expected_source = "\"#{entity.name}(#{entity.arguments[0]})\" => Proc.new { |year|\n#{entity.source}}"
+
+    assert_equal expected_source, source
+  end
+
+  def test_call_raises_error_if_missing_name
+    entity = Holidays::Definition::Entity::CustomMethod.new(
+      arguments: ["year", "month"],
+      source: "Date.civil(year, month, 1)"
+    )
+
+    assert_raises ArgumentError do
+      @decorator.call(entity)
+    end
+  end
+
+  def test_call_raises_error_if_missing_arguments
+    entity = Holidays::Definition::Entity::CustomMethod.new(
+      name: "test",
+      source: "Date.civil(year, month, 1)"
+    )
+
+    assert_raises ArgumentError do
+      @decorator.call(entity)
+    end
+  end
+
+  def test_call_raises_error_if_arguments_is_not_an_array
+    entity = Holidays::Definition::Entity::CustomMethod.new(
+      name: "test",
+      arguments: "test",
+      source: "Date.civil(year, month, 1)"
+    )
+
+    assert_raises ArgumentError do
+      @decorator.call(entity)
+    end
+  end
+
+  def test_call_raises_error_if_missing_source
+    entity = Holidays::Definition::Entity::CustomMethod.new(
+      name: "test",
+      arguments: ["year", "month"],
+    )
+
+    assert_raises ArgumentError do
+      @decorator.call(entity)
+    end
+  end
+end

data/test/holidays/definition/parser/test_custom_method.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/definition/parser/custom_method'
+require 'holidays/definition/entity/custom_method'
+
+class ParserCustomMethodTests < Test::Unit::TestCase
+  def setup
+    @validator = mock()
+
+    @parser = Holidays::Definition::Parser::CustomMethod.new(@validator)
+  end
+
+  def test_parse_happy_single_method
+    input = {"custom_method"=>{"arguments"=>"year", "source"=>"d = Date.civil(year, 1, 1)\nd + 2\n"}}
+    @validator.expects(:valid?).with({:name => "custom_method", :arguments => "year", :source => "d = Date.civil(year, 1, 1)\nd + 2\n"}).returns(true)
+
+    result = @parser.call(input)
+
+    assert_equal(1, result.size)
+
+    custom_method = result["custom_method(year)"]
+    assert(custom_method)
+
+    assert(custom_method.is_a?(Holidays::Definition::Entity::CustomMethod))
+    assert_equal("custom_method", custom_method.name)
+    assert_equal(["year"], custom_method.arguments)
+    assert_equal("d = Date.civil(year, 1, 1)\nd + 2\n", custom_method.source)
+  end
+
+  def test_call_happy_with_multiple_methods
+    input = {"custom_method"=>{"arguments"=>"year", "source"=>"d = Date.civil(year, 1, 1)\nd + 2\n"}, "second_method"=>{"arguments"=>"month","source"=>"source"}}
+    @validator.expects(:valid?).with({:name => "custom_method", :arguments => "year", :source => "d = Date.civil(year, 1, 1)\nd + 2\n"}).returns(true)
+    @validator.expects(:valid?).with({:name => "second_method", :arguments => "month", :source => "source"}).returns(true)
+
+    result = @parser.call(input)
+
+    assert_equal(2, result.size)
+
+    custom_method = result["custom_method(year)"]
+    assert(custom_method)
+
+    assert(custom_method.is_a?(Holidays::Definition::Entity::CustomMethod))
+    assert_equal("custom_method", custom_method.name)
+    assert_equal(["year"], custom_method.arguments)
+    assert_equal("d = Date.civil(year, 1, 1)\nd + 2\n", custom_method.source)
+
+    second_method= result["second_method(month)"]
+    assert(second_method)
+
+    assert(second_method.is_a?(Holidays::Definition::Entity::CustomMethod))
+    assert_equal("second_method", second_method.name)
+    assert_equal(["month"], second_method.arguments)
+    assert_equal("source", second_method.source)
+  end
+
+  def test_call_returns_empty_hash_if_methods_are_missing
+    assert_equal({}, @parser.call(nil))
+    assert_equal({}, @parser.call({}))
+  end
+
+  def test_call_raises_error_if_validator_returns_false_for_single_method
+    input = {"custom_method"=>{"arguments"=>"year", "source"=>"d = Date.civil(year, 1, 1)\nd + 2\n"}}
+    @validator.expects(:valid?).with({:name => "custom_method", :arguments => "year", :source => "d = Date.civil(year, 1, 1)\nd + 2\n"}).returns(false)
+
+    assert_raises ArgumentError do
+      result = @parser.call(input)
+    end
+  end
+
+  def test_call_raises_error_if_validator_returns_false_for_one_of_multiple_methods
+    input = {"custom_method"=>{"arguments"=>"year", "source"=>"d = Date.civil(year, 1, 1)\nd + 2\n"}, "second_method"=>{"arguments"=>"month","source"=>"source"}}
+    @validator.expects(:valid?).with({:name => "custom_method", :arguments => "year", :source => "d = Date.civil(year, 1, 1)\nd + 2\n"}).returns(true)
+    @validator.expects(:valid?).with({:name => "second_method", :arguments => "month", :source => "source"}).returns(false)
+
+    assert_raises ArgumentError do
+      result = @parser.call(input)
+    end
+  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

@@ -93,22 +93,6 @@ class HolidaysByMonthRepoTests < Test::Unit::TestCase
     assert_equal(expected, @subject.all)
   end
 
-  def test_add_is_successful_if_function_id_is_different
-    target_holidays = {0 => [:mday => 1, :name => "Test", :function_id => 'test', :regions => [:test]]}
-
-    @subject.add(@existing_holidays_by_month)
-    @subject.add(target_holidays)
-
-    expected = {
-                 0 => [
-                        {:mday=>1, :name=>"Test", :regions=>[:test]},
-                        {:mday=>1, :name=>"Test", :function_id => 'test', :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]]}
 
@@ -125,22 +109,6 @@ class HolidaysByMonthRepoTests < Test::Unit::TestCase
     assert_equal(expected, @subject.all)
   end
 
-  def test_add_is_successful_if_observed_id_is_different
-    target_holidays = {0 => [:mday => 1, :name => "Test", :observed_id => :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", :observed_id => :informal, :regions=>[:test]}
-                      ]
-                }
-
-    assert_equal(expected, @subject.all)
-  end
-
   def test_add_is_successful_and_updates_regions_to_existing_matching_definitions
     target_holidays = {0 => [:mday => 1, :name => "Test", :regions => [:test2]]}
 

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

@@ -0,0 +1,84 @@
+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_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
+
+    funtion_argument = Proc.new { |arg1| "arg1" + "something"}
+    assert_raise ArgumentError do
+      @subject.lookup(function, function_argument)
+    end
+  end
+end

data/test/holidays/definition/validator/test_custom_method.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/definition/validator/custom_method'
+
+class CustomMethodValidatorTests < Test::Unit::TestCase
+  def setup
+    @subject = Holidays::Definition::Validator::CustomMethod.new
+  end
+
+  def test_valid_returns_true_if_valid
+    m = {:name => "good_method", :arguments => "year", :source => "source"}
+    assert @subject.valid?(m)
+  end
+
+  def test_valid_returns_true_with_multiple_arguments
+    m = {:name => "good_method", :arguments => "year,month", :source => "source"}
+    assert @subject.valid?(m)
+  end
+
+  def test_valid_returns_true_with_date_argument
+    m = {:name => "good_method", :arguments => "date", :source => "source"}
+    assert @subject.valid?(m)
+  end
+
+  def test_valid_returns_true_with_year_argument
+    m = {:name => "good_method", :arguments => "year", :source => "source"}
+    assert @subject.valid?(m)
+  end
+
+  def test_valid_returns_true_with_month_argument
+    m = {:name => "good_method", :arguments => "month", :source => "source"}
+    assert @subject.valid?(m)
+  end
+
+  def test_valid_returns_true_with_day_argument
+    m = {:name => "good_method", :arguments => "day", :source => "source"}
+    assert @subject.valid?(m)
+  end
+
+  def test_valid_returns_true_multiple_arguments_with_whitespace
+    m = {:name => "good_method", :arguments => "year        ,          month", :source => "source"}
+    assert @subject.valid?(m)
+  end
+
+  def test_valid_returns_false_if_single_argument_contain_carriage_return
+    m = {:name => "bad_method", :arguments =>"year\n", :source =>"d = Date.civil(year, 1, 1)\nd + 2\n"}
+    assert_false @subject.valid?(m)
+  end
+
+  def test_valid_returns_false_if_multiple_arguments_contain_carriage_return
+    m = {:name => "bad_method", :arguments =>"year,month\n", :source =>"d = Date.civil(year, 1, 1)\nd + 2\n"}
+    assert_false @subject.valid?(m)
+  end
+
+  def test_valid_returns_false_if_multiple_arguments_contain_carriage_return_with_whitespace
+    m = {:name => "bad_method", :arguments =>"year          ,         month\n", :source =>"d = Date.civil(year, 1, 1)\nd + 2\n"}
+    assert_false @subject.valid?(m)
+  end
+
+  def test_valid_returns_false_if_no_source
+    m = {:name => "bad_method", :arguments => "day"}
+    assert_false @subject.valid?(m)
+  end
+
+  def test_valid_returns_false_if_source_is_empty
+    m = {:name => "bad_method", :arguments => "day", :source => ""}
+    assert_false @subject.valid?(m)
+  end
+
+  def test_valid_returns_false_if_name_is_missing
+    m = {:arguments => "day", :source => "source"}
+    assert_false @subject.valid?(m)
+  end
+
+  def test_valid_returns_false_if_name_is_empty
+    m = {:name => "", :arguments => "day", :source => "source"}
+    assert_false @subject.valid?(m)
+  end
+
+  def test_returns_false_if_multiple_arguments_contain_unrecognized_value
+    m = {:name => "bad_method", :arguments => "year,month,day,date,unknown", :source => "source"}
+    assert_false @subject.valid?(m)
+  end
+
+  def test_returns_false_if_single_argument_contains_unrecognized_value
+    m = {:name => "bad_method", :arguments => "unknown", :source => "source"}
+    assert_false @subject.valid?(m)
+  end
+end

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

@@ -15,9 +15,14 @@ class ParseOptionsTests < Test::Unit::TestCase
     @region_validator = mock()
     @region_validator.stubs(:valid?).returns(true)
 
+    # As mentioned above, this set of tests is NOT isolated. We need
+    # the real merger code here.
+    @definition_merger = Holidays::DefinitionFactory.merger
+
     @subject = Holidays::Option::Context::ParseOptions.new(
       @regions_repo,
       @region_validator,
+      @definition_merger,
     )
   end