holidays 9.2.0 → 10.0.0

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

@@ -1,79 +0,0 @@
-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", "ruby"=>"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", "ruby"=>"d = Date.civil(year, 1, 1)\nd + 2\n"}, "second_method"=>{"arguments"=>"month","ruby"=>"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", "ruby"=>"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
-      @parser.call(input)
-    end
-  end
-
-  def test_call_raises_error_if_validator_returns_false_for_one_of_multiple_methods
-    input = {"custom_method"=>{"arguments"=>"year", "ruby"=>"d = Date.civil(year, 1, 1)\nd + 2\n"}, "second_method"=>{"arguments"=>"month","ruby"=>"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
-      @parser.call(input)
-    end
-  end
-end

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

@@ -1,142 +0,0 @@
-# Heh at this file name
-require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
-
-require 'holidays/definition/parser/test'
-require 'holidays/definition/entity/test'
-
-class ParserTestTests < Test::Unit::TestCase
-  def setup
-    @validator = mock()
-
-    @parser = Holidays::Definition::Parser::Test.new(@validator)
-  end
-
-  def test_parse_no_tests
-    input = nil
-    result = @parser.call(input)
-
-    assert_equal(0, result.size)
-  end
-
-  def test_parse_single_test_happy
-    input = [ { "given" => { "date" => "2016-01-01", "regions" => ['us'] }, "expect" => { "name" => "Test Holiday" } } ]
-    @validator.expects(:valid?).with({:dates => ["2016-01-01"], :regions=> ['us'], :options => nil, :name => "Test Holiday", :holiday => nil}).returns(true)
-
-    result = @parser.call(input)
-
-    assert_equal(1, result.size)
-
-    test = result.first
-    assert(test)
-
-    assert(test.is_a?(Holidays::Definition::Entity::Test))
-    assert_equal([DateTime.parse('2016-01-01')], test.dates)
-    assert_equal([:us], test.regions)
-    assert_equal("Test Holiday", test.name)
-    assert(test.holiday?)
-  end
-
-  def test_parse_single_test_with_options
-    input = [ { "given" => { "date" => "2016-01-01", "regions" => ['us'], "options" => ['option1']}, "expect" => { "name" => "Test Holiday" } } ]
-    @validator.expects(:valid?).with({:dates => ["2016-01-01"], :regions=> ['us'], :name => "Test Holiday", :options => ['option1'], :holiday => nil}).returns(true)
-
-    result = @parser.call(input)
-
-    assert_equal(1, result.size)
-
-    test = result.first
-    assert(test)
-
-    assert(test.is_a?(Holidays::Definition::Entity::Test))
-    assert_equal([DateTime.parse('2016-01-01')], test.dates)
-    assert_equal([:us], test.regions)
-    assert_equal([:option1], test.options)
-    assert_equal("Test Holiday", test.name)
-    assert(test.holiday?)
-  end
-
-  def test_parse_single_test_with_single_option_as_string
-    input = [ { "given" => { "date" => "2016-01-01", "regions" => ['us'], "options" => 'option1'}, "expect" => { "name" => "Test Holiday" } } ]
-    @validator.expects(:valid?).with({:dates => ["2016-01-01"], :regions=> ['us'], :name => "Test Holiday", :options => 'option1', :holiday => nil}).returns(true)
-
-    result = @parser.call(input)
-
-    assert_equal(1, result.size)
-
-    test = result.first
-    assert(test)
-
-    assert(test.is_a?(Holidays::Definition::Entity::Test))
-    assert_equal([DateTime.parse('2016-01-01')], test.dates)
-    assert_equal([:us], test.regions)
-    assert_equal([:option1], test.options)
-    assert_equal("Test Holiday", test.name)
-    assert(test.holiday?)
-  end
-
-  def test_parse_single_test_no_name_no_holiday
-    input = [ { "given" => { "date" => "2016-01-01", "regions" => ['us']}, "expect" => { "holiday" => false } } ]
-    @validator.expects(:valid?).with({:dates => ["2016-01-01"], :regions=> ['us'], :name => nil, :options => nil, :holiday => false}).returns(true)
-
-    result = @parser.call(input)
-
-    assert_equal(1, result.size)
-
-    test = result.first
-    assert(test)
-
-    assert(test.is_a?(Holidays::Definition::Entity::Test))
-    assert_equal([DateTime.parse('2016-01-01')], test.dates)
-    assert_equal([:us], test.regions)
-    assert_nil(test.options)
-    assert_nil(test.name)
-    assert_equal(false, test.holiday?)
-  end
-
-  def test_parse_single_test_with_options_no_name_no_holiday
-    input = [ { "given" => { "date" => "2016-01-01", "regions" => ['us'], "options" => ['option1']}, "expect" => { "holiday" => false } } ]
-    @validator.expects(:valid?).with({:dates => ["2016-01-01"], :regions=> ['us'], :name => nil, :options => ['option1'], :holiday => false}).returns(true)
-
-    result = @parser.call(input)
-
-    assert_equal(1, result.size)
-
-    test = result.first
-    assert(test)
-
-    assert(test.is_a?(Holidays::Definition::Entity::Test))
-    assert_equal([DateTime.parse('2016-01-01')], test.dates)
-    assert_equal([:us], test.regions)
-    assert_equal([:option1], test.options)
-    assert_nil(test.name)
-    assert_equal(false, test.holiday?)
-  end
-
-  def test_parse_single_test_multiple_dates
-    input = [ { "given" => { "date" => ["2016-01-01", "2017-01-01"], "regions" => ['us']}, "expect" => { "name" => "Test Holiday"} } ]
-    @validator.expects(:valid?).with({:dates => ["2016-01-01", "2017-01-01"], :regions=> ['us'], :name => "Test Holiday", :options => nil, :holiday => nil}).returns(true)
-
-    result = @parser.call(input)
-
-    assert_equal(1, result.size)
-
-    test = result.first
-    assert(test)
-
-    assert(test.is_a?(Holidays::Definition::Entity::Test))
-    assert_equal([DateTime.parse('2016-01-01'), DateTime.parse('2017-01-01')], test.dates)
-    assert_equal([:us], test.regions)
-    assert_nil(test.options)
-    assert_equal("Test Holiday", test.name)
-    assert(test.holiday?)
-  end
-
-  def test_parse_single_test_fail_validation
-    input = [ { "given" => { "date" => "2016-01-01", "regions" => ['us']}, "expect" => { "name" => "Test Holiday"} } ]
-    @validator.expects(:valid?).with({:dates => ["2016-01-01"], :regions=> ['us'], :name => "Test Holiday", :options => nil, :holiday => nil}).returns(false)
-
-    assert_raises ArgumentError do
-      @parser.call(input)
-    end
-  end
-end

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

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

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

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