ndr_support 5.10.4 → 5.10.5

data/gemfiles/Gemfile.rails80

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec path: '..'
-
-gem 'activerecord',  '~> 8.0.0'
-gem 'activesupport', '~> 8.0.0'

data/test/array_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-# This tests our Array extension
-class ArrayTest < Minitest::Test
-  test 'Arrays should be extended with #permutations' do
-    assert [].respond_to?(:permutations)
-  end
-
-  test 'Array#permutations should calculate permutations correctly' do
-    array = [1, 2, 3]
-    permutations = [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
-    assert_equal array.length.factorial, array.permutations.length
-    assert_equal permutations.sort, array.permutations.sort
-  end
-
-  test 'Array#permutations should permute duplicates' do
-    array = [1, 1]
-    assert_equal [[1, 1], [1, 1]], array.permutations
-  end
-end

data/test/concerns/working_days_test.rb

@@ -1,148 +0,0 @@
-require 'test_helper'
-
-# This tests our WorkingDays Time/Date/DateTime extension
-class WorkingDaysTest < Minitest::Test
-  def setup
-    @normal_date      = Date.parse('2015-02-02')          # Monday 2nd Feb 2015
-    @normal_time      = Time.parse('2015-02-02 2pm')      # Monday 2nd Feb 2015
-    @normal_date_time = DateTime.parse('2015-02-02 11am') # Monday 2nd Feb 2015
-
-    @easter_date      = Date.parse('2015-04-06')          # Easter Monday, 2015
-    @easter_time      = Time.parse('2015-04-06 2pm')      # Easter Monday, 2015
-    @easter_date_time = DateTime.parse('2015-04-06 11am') # Easter Monday, 2015
-  end
-
-  test 'should identify weekdays' do
-    assert Date.parse('2015-12-25').weekday?
-    assert Time.parse('2015-12-25 3pm').weekday?
-    assert DateTime.parse('2015-12-25 3pm').weekday?
-
-    refute Date.parse('2015-12-26').weekday?
-    refute Time.parse('2015-12-26 3pm').weekday?
-    refute DateTime.parse('2015-12-26 3pm').weekday?
-  end
-
-  test 'should identify bank holidays' do
-    assert Date.parse('2015-12-25').public_holiday?
-    assert Time.parse('2015-12-25 3pm').public_holiday?
-    assert DateTime.parse('2015-12-25 3pm').public_holiday?
-
-    # Boxing Day 2015 is a Saturday; the bank holiday a
-    # substitute day, on the following Monday:
-    refute Date.parse('2015-12-26').public_holiday?
-    refute Time.parse('2015-12-26 3pm').public_holiday?
-    refute DateTime.parse('2015-12-26 3pm').public_holiday?
-
-    assert Date.parse('2015-12-28').public_holiday?
-    assert Time.parse('2015-12-28 3pm').public_holiday?
-    assert DateTime.parse('2015-12-28 3pm').public_holiday?
-  end
-
-  test 'should allow comparison of Time and DateTime' do
-    @normal_time.working_days_until(@normal_date_time)
-    @normal_date_time.working_days_until(@normal_time)
-  end
-
-  test 'should allow comparison of DateTime and Date' do
-    @normal_date_time.working_days_until(@normal_date)
-    @normal_date.working_days_until(@normal_date_time)
-  end
-
-  test 'should be zero working days between same normal day' do
-    assert_equal 0, @normal_date.working_days_until(@normal_date)
-    assert_equal 0, @normal_time.working_days_until(@normal_time + 6.hours)
-    assert_equal 0, @normal_date_time.working_days_until(@normal_date_time + 6.hours)
-  end
-
-  test 'Monday -> Friday should be 4 working days' do
-    assert_equal 4, @normal_date.working_days_until(@normal_date + 4.days)
-    assert_equal 4, @normal_time.working_days_until(@normal_time + 4.days)
-    assert_equal 4, @normal_date_time.working_days_until(@normal_date_time + 4.days)
-  end
-
-  test 'Friday <- Monday should be -4 working days' do
-    assert_equal(-4, (@normal_date + 4.days).working_days_until(@normal_date))
-    assert_equal(-4, (@normal_time + 4.days).working_days_until(@normal_time))
-    assert_equal(-4, (@normal_date_time + 4.days).working_days_until(@normal_date_time))
-  end
-
-  test 'Saturday -> Sunday should be 0 working days' do
-    assert_equal 0, (@normal_date - 2.days).working_days_until(@normal_date - 1.day)
-    assert_equal 0, (@normal_time - 2.days).working_days_until(@normal_time - 1.day)
-    assert_equal 0, (@normal_date_time - 2.days).working_days_until(@normal_date_time - 1.day)
-  end
-
-  test 'Sunday <- Saturday should be 0 working days' do
-    assert_equal 0, (@normal_date - 1.day).working_days_until(@normal_date - 2.days)
-    assert_equal 0, (@normal_time - 1.day).working_days_until(@normal_time - 2.days)
-    assert_equal 0, (@normal_date_time - 1.day).working_days_until(@normal_date_time - 2.days)
-  end
-
-  test 'Monday -> next Monday should be 5 working days' do
-    assert_equal 5, @normal_date.working_days_until(@normal_date + 7.days)
-    assert_equal 5, @normal_time.working_days_until(@normal_time + 7.days)
-    assert_equal 5, @normal_date_time.working_days_until(@normal_date_time + 7.days)
-  end
-
-  test 'Monday -> Easter Monday should be 3 working days' do
-    assert_equal 3, (@easter_date - 7.days).working_days_until(@easter_date)
-    assert_equal 3, (@easter_time - 7.days).working_days_until(@easter_time)
-    assert_equal 3, (@easter_date_time - 7.days).working_days_until(@easter_date_time)
-  end
-
-  test 'Tuesday -> Tuesday over Easter should be 3 working days' do
-    assert_equal 3, (@easter_date - 6.days).working_days_until(@easter_date + 1.day)
-    assert_equal 3, (@easter_time - 6.days).working_days_until(@easter_time + 1.day)
-    assert_equal 3, (@easter_date_time - 6.days).working_days_until(@easter_date_time + 1.day)
-  end
-
-  test 'Good Friday -> Friday should be 4 working days' do
-    assert_equal 4, (@easter_date - 3.days).working_days_until(@easter_date + 4.day)
-    assert_equal 4, (@easter_time - 3.days).working_days_until(@easter_time + 4.day)
-    assert_equal 4, (@easter_date_time - 3.days).working_days_until(@easter_date_time + 4.day)
-  end
-
-  test 'Friday -> Monday should be 1 working day' do
-    assert_equal 1, (@normal_date - 3.days).working_days_until(@normal_date)
-    assert_equal 1, (@normal_time - 3.days).working_days_until(@normal_time)
-    assert_equal 1, (@normal_date_time - 3.days).working_days_until(@normal_date_time)
-  end
-
-  test 'A year of week days' do
-    assert_equal 261, @normal_date.weekdays_until(@normal_date + 1.year)
-    assert_equal 261, @normal_time.weekdays_until(@normal_time + 1.year)
-    assert_equal 261, @normal_date_time.weekdays_until(@normal_date_time + 1.year)
-  end
-
-  test 'A year of working days' do
-    assert_equal 253, @normal_date.working_days_until(@normal_date + 1.year)
-    assert_equal 253, @normal_time.working_days_until(@normal_time + 1.year)
-    assert_equal 253, @normal_date_time.working_days_until(@normal_date_time + 1.year)
-  end
-
-  test 'against GOV.UK holidays' do
-    require 'net/http'
-    require 'json'
-
-    url = 'https://www.gov.uk/bank-holidays/england-and-wales.json'
-    response = Net::HTTP.get(URI(url))
-
-    events = JSON.parse(response)['events']
-    missing_holidays = events.collect do |event|
-      event_date = event['date']
-      parsed_date = Date.parse(event_date)
-      if parsed_date.public_holiday?
-        nil
-      else
-        [event_date, format("    '%<date>s', # %<day>-9s - %<title>s",
-                            date: event_date, day: parsed_date.strftime('%A'),
-                            title: event['title'])]
-      end
-    end.compact
-    if missing_holidays.any?
-      flunk (["#{missing_holidays.collect(&:first).join(', ')} should be public holidays in " \
-              'lib/ndr_support/concerns/working_days.rb:'] +
-             missing_holidays.collect(&:last)).join("\n")
-    end
-  end
-end

data/test/date_and_time_extensions_test.rb

@@ -1,82 +0,0 @@
-require 'test_helper'
-
-# This tests our various date and time class extensions
-# Note that these will probably all need to be changed in a major bump of ndr_support
-# once we've moved everything to Rails 7.
-class DateAndTimeExtensionsTest < Minitest::Test
-  def test_date_to_s
-    d = Date.new(2000, 2, 1)
-    if d.respond_to?(:to_default_s) # Only defined on Rails <= 7.1
-      assert_equal '2000-02-01', d.to_default_s, 'Rails 7 default to_s'
-    else
-      assert_equal '2000-02-01', d.orig_to_s, 'Rails 7 default to_s (via our shim)'
-    end
-    assert_equal '01.02.2000', d.to_formatted_s(:default), 'Rails 6 default to_s'
-    assert_equal d.to_formatted_s(:default), d.to_s,
-                 'We plan to change default to_s behaviour in a major version bump'
-  end
-
-  def test_datetime_to_s
-    bst_datetime = DateTime.new(2014, 4, 1, 0, 0, 0, '+1')
-    if bst_datetime.respond_to?(:to_default_s) # Only defined on Rails <= 7.1
-      assert_equal '2014-04-01T00:00:00+01:00', bst_datetime.to_default_s, 'Rails 7 default to_s'
-    else
-      assert_equal '2014-04-01T00:00:00+01:00', bst_datetime.orig_to_s, 'Rails 7 default to_s (via our shim)'
-    end
-    assert_equal '01.04.2014', bst_datetime.to_formatted_s(:default), 'Rails 6 default to_s'
-    assert_equal bst_datetime.to_formatted_s(:default), bst_datetime.to_s,
-                 'We plan to change default to_s behaviour in a major version bump'
-
-    gmt_datetime = DateTime.new(2014, 3, 1, 0, 0, 0, '+0')
-    if gmt_datetime.respond_to?(:to_default_s) # Only defined on Rails <= 7.1
-      assert_equal '2014-03-01T00:00:00+00:00', gmt_datetime.to_default_s, 'Rails 7 default to_s'
-    else
-      assert_equal '2014-03-01T00:00:00+00:00', gmt_datetime.orig_to_s, 'Rails 7 default to_s (via our shim)'
-    end
-    assert_equal '01.03.2014', gmt_datetime.to_formatted_s(:default), 'Rails 6 default to_s'
-    assert_equal gmt_datetime.to_formatted_s(:default), gmt_datetime.to_s,
-                 'We plan to change default to_s behaviour in a major version bump'
-
-    datetime_with_hhmmss = DateTime.new(2014, 4, 1, 12, 35, 11, '+0')
-    if datetime_with_hhmmss.respond_to?(:to_default_s) # Only defined on Rails <= 7.1
-      assert_equal '2014-04-01T12:35:11+00:00', datetime_with_hhmmss.to_default_s,
-                   'Rails 7 default to_s'
-    else
-      assert_equal '2014-04-01T12:35:11+00:00', datetime_with_hhmmss.orig_to_s,
-                   'Rails 7 default to_s (via our shim)'
-    end
-    assert_equal '01.04.2014 12:35', datetime_with_hhmmss.to_formatted_s(:default),
-                 'Rails 6 default to_s'
-    assert_equal datetime_with_hhmmss.to_formatted_s(:default), datetime_with_hhmmss.to_s,
-                 'We plan to change default to_s behaviour in a major version bump'
-  end
-
-  def test_time_to_s
-    time = Time.new(2014, 4, 1, 12, 35, 11.5, '+01:00')
-    if time.respond_to?(:to_default_s) # Only defined on Rails <= 7.1
-      assert_equal '2014-04-01 12:35:11 +0100', time.to_default_s, 'Rails 7 default to_s'
-    else
-      assert_equal '2014-04-01 12:35:11 +0100', time.orig_to_s, 'Rails 7 default to_s (via our shim)'
-    end
-    assert_equal '01.04.2014 12:35', time.to_formatted_s(:default), 'Rails 6 default to_s'
-    assert_equal time.to_formatted_s(:default), time.to_s,
-                 'We plan to change default to_s behaviour in a major version bump'
-  end
-
-  def test_time_with_zone_to_s
-    time_with_zone = Time.find_zone('Europe/London').local(2014, 4, 1, 12, 35, 11.5)
-    assert_equal 'BST', time_with_zone.zone
-    # Without ndr_support extensions, we'd expect "2014-04-01 12:35:11 +0100"
-    # but we have to trick the database into assuming all times are UTC to retain local time
-    if time_with_zone.respond_to?(:to_default_s) # Only defined on Rails <= 7.1
-      assert_equal '2014-04-01 12:35:11 UTC', time_with_zone.to_default_s,
-                   'Rails 7 default to_s with our date and time formatting'
-    else
-      assert_equal '2014-04-01 12:35:11 +0100', time_with_zone.orig_to_s,
-                   'Rails 7 default to_s with our date and time formatting (via our shim)'
-    end
-    assert_equal '01.04.2014 12:35', time_with_zone.to_formatted_s(:default), 'Rails 6 default to_s'
-    assert_equal time_with_zone.to_formatted_s(:default), time_with_zone.to_s,
-                 'We plan to change default to_s behaviour in a major version bump'
-  end
-end

data/test/daterange_test.rb

@@ -1,303 +0,0 @@
-require 'test_helper'
-
-# This tests our Daterange class
-class DaterangeTest < Minitest::Test
-  def test_basic_creation
-    dr = Daterange.new
-    assert_equal '', dr.to_s
-    assert_nil dr.date1
-    assert_nil dr.date2
-    assert dr.empty?
-    assert dr.blank?  # delegates to dr.empty?
-  end
-
-  def test_creation_from_dates
-    d = Date.today
-    dr = Daterange.new d, d
-    assert_nil dr.source
-    refute_nil dr.date1
-    refute_nil dr.date2
-    refute dr.empty?
-    assert_equal d.to_s, dr.to_s # because just one day
-    # assert_match(/\d\d\.\d\d\.\d\d\d\d/, dr.to_s) # default format
-    # dr = Daterange.new d, d + 1
-    # assert_match(/\d\d\.\d\d\.\d\d\d\d to \d\d.\d\d.\d\d\d\d/, dr.to_s)
-  end
-
-  def test_date_time_dates_in_reverse_order_with_do_not_sort_dates_false
-    d = Time.zone.today
-    dr = Daterange.new(d, d + 1)
-    dr2 = Daterange.new(d + 1, d)
-    assert_equal(dr.to_s, dr2.to_s)
-  end
-
-  def test_blank_does_not_trigger_error_and_returns_nil_in_dates
-    dr = Daterange.new('', do_not_sort_dates: true)
-    assert_nil dr.date1
-    assert_nil dr.date2
-  end
-
-  def test_date_time_dates_in_reverse_order_with_do_not_sort_dates_true
-    d = Time.zone.today
-    Daterange.new(d, d + 1, do_not_sort_dates: true)
-    assert_raises(Daterange::WrongDateOrderError) do
-      Daterange.new(d + 1, d, do_not_sort_dates: true)
-    end
-  end
-
-  def test_string_dates_in_reverse_order_with_do_not_sort_dates_false
-    dr = Daterange.new('01/01/2019 to 01/01/2020')
-    dr2 = Daterange.new('01/01/2020 to 01/01/2019')
-    assert_equal(dr.to_s, dr2.to_s)
-  end
-
-  def test_string_dates_in_reverse_order_with_do_not_sort_dates_true
-    Daterange.new('01/01/2019 to 01/01/2020', do_not_sort_dates: true)
-    assert_raises(Daterange::WrongDateOrderError) do
-      Daterange.new('01/01/2020 to 01/01/2019', do_not_sort_dates: true)
-    end
-  end
-
-  def test_illegal_strings
-    dr = Daterange.new('01/o1/2000')
-    assert_equal '', dr.to_s
-    assert_nil dr.date1
-    assert_nil dr.date2
-    refute dr.empty? # Illegal dates do not count as empty / blank,
-    refute_nil dr.source # but the illegal string is preserved
-
-    dr = Daterange.new('01_01_2000')
-    assert_equal '', dr.to_s
-    assert_nil dr.date1
-    assert_nil dr.date2
-    refute dr.empty? # Illegal dates do not count as empty / blank,
-    refute_nil dr.source # but the illegal string is preserved
-  end
-
-  def test_out_of_range
-    dr = Daterange.new('31/12/1879')
-    assert_equal '', dr.to_s
-    assert_nil dr.date1
-    assert_nil dr.date2
-  end
-
-  def test_year_attributes
-    dr = Daterange.new('2000')
-    assert_equal '2000', dr.source
-    assert_equal '2000', dr.to_s
-    assert_equal '01.01.2000', dr.date1.to_s
-    assert_equal '31.12.2000', dr.date2.to_s
-  end
-
-  def test_year_range_attributes
-    dr = Daterange.new('1880 2020')
-    assert_equal '01.01.1880 to 31.12.2020', dr.to_s
-    assert_equal '01.01.1880', dr.date1.to_s
-    assert_equal '31.12.2020', dr.date2.to_s
-    assert_equal '1880 2020', dr.source
-  end
-
-  def test_year_range_future
-    s = 2.years.from_now.strftime('%Y')
-    dr = Daterange.new(s)
-    assert_equal s, dr.to_s, "Daterange should support future years up to #{s}"
-  end
-
-  def test_hyphen_month_input_style
-    dr = Daterange.new('2000-05')
-    assert_equal '05.2000', dr.to_s
-  end
-
-  def test_dot_month_input_style
-    dr = Daterange.new('06.2000')
-    assert_equal '01.06.2000', dr.date1.to_s
-    assert_equal '30.06.2000', dr.date2.to_s
-    assert_equal '06.2000', dr.to_s
-  end
-
-  def test_forwardslash_month_input_style
-    dr = Daterange.new('07/2000')
-    assert_equal '07.2000', dr.to_s
-    assert_equal '01.07.2000', dr.date1.to_s
-    assert_equal '31.07.2000', dr.date2.to_s
-  end
-
-  def test_noseparator_month_input_style
-    dr = Daterange.new('082000')
-    assert_equal '08.2000', dr.to_s
-    assert_equal '01.08.2000', dr.date1.to_s
-    assert_equal '31.08.2000', dr.date2.to_s
-  end
-
-  def test_date_to_date_input_style
-    dr = Daterange.new('01.05.2000 to 31.05.2000')
-    assert_equal '05.2000', dr.to_s
-    assert_equal '01.05.2000', dr.date1.to_s
-    assert_equal '31.05.2000', dr.date2.to_s
-    dr = Daterange.new('2000 TO 2001')
-    assert_equal '01.01.2000 to 31.12.2001', dr.to_s
-  end
-
-  def test_hyphen_date_input_style
-    dr = Daterange.new('2000-09-12')
-    assert_equal '12.09.2000', dr.to_s
-  end
-
-  def test_forwardslash_date_input_style
-    dr = Daterange.new('13/09/2000')
-    assert_equal '13.09.2000', dr.to_s
-  end
-
-  def test_dot_date_input_style
-    dr = Daterange.new('14.09.2000')
-    assert_equal '14.09.2000', dr.to_s
-  end
-
-  def test_noseparator_date_input_style
-    dr = Daterange.new('15092000')
-    assert_equal '15.09.2000', dr.to_s
-  end
-
-  def test_spen_daylight_saving
-    dr = Daterange.new('03.2010') # Span time zones (daylight saving)
-    assert_equal '03.2010', dr.to_s # Ideally '03.2010'
-  end
-
-  def test_date_with_daylight_saving
-    dr = Daterange.new(Date.new(2017, 9, 2)) # During daylight saving
-    assert_equal '02.09.2017', dr.to_s
-    default_timezone = ActiveRecord.default_timezone
-    return unless default_timezone == :local
-
-    assert_equal Date.new(2017, 9, 2).in_time_zone.utc_offset, dr.date1.utc_offset, 'Expect consistent offset'
-    assert_equal '2017-09-02'.thetime, dr.date1
-  end
-
-  def test_verbose
-    dr = Daterange.new('01.03.2010')
-    assert_equal '01 March 2010', dr.verbose
-  end
-
-  def test_verbose_range
-    dr = Daterange.new('03.2010 to 2014')
-    assert_equal 'The period 01 March 2010 to 31 December 2014 inclusive (1767 days)', dr.verbose
-  end
-
-  def test_year_intersection
-    dr1 = Daterange.new('2001')
-    dr2 = Daterange.new('2002')
-    refute dr1.intersects?(dr2)
-    refute dr2.intersects?(dr1)
-
-    dr1 = Daterange.new('2001')
-    dr2 = Daterange.new('2001')
-    assert dr1.intersects?(dr2)
-    assert dr2.intersects?(dr1)
-  end
-
-  def test_year_range_intersection
-    dr1 = Daterange.new('2001 to 2003')
-    dr2 = Daterange.new('2002 to 2004')
-    assert dr1.intersects?(dr2)
-    assert dr2.intersects?(dr1)
-  end
-
-  def test_subset_intersection
-    dr1 = Daterange.new('01.05.2000 to 31.05.2000')
-    dr2 = Daterange.new('02.05.2000 to 30.05.2000')
-    assert dr1.intersects?(dr2)
-    assert dr2.intersects?(dr1)
-  end
-
-  def test_smallest_inhabited_intersection
-    dr1 = Daterange.new('01.05.2000 to 31.05.2000')
-    dr2 = Daterange.new('01.04.2000 to 01.05.2000')
-    assert dr1.intersects?(dr2)
-    assert dr2.intersects?(dr1)
-
-    dr1 = Daterange.new('01.05.2000 to 31.05.2000')
-    dr2 = Daterange.new('31.05.2000 to 01.06.2000')
-    assert dr1.intersects?(dr2)
-    assert dr2.intersects?(dr1)
-  end
-
-  def test_disjointed_intersection
-    dr1 = Daterange.new('02.05.2000 to 31.05.2000')
-    dr2 = Daterange.new('01.04.2000 to 01.05.2000')
-    refute dr1.intersects?(dr2)
-    refute dr2.intersects?(dr1)
-  end
-
-  def test_real_empty_intersection
-    dr1 = Daterange.new
-    dr2 = Daterange.new('01.04.2000 to 01.05.2000')
-    refute dr1.intersects?(dr2)
-    refute dr2.intersects?(dr1)
-
-    dr1 = Daterange.new('01.04.2000 to 01.05.2000')
-    dr2 = Daterange.new
-    refute dr1.intersects?(dr2)
-    refute dr2.intersects?(dr1)
-  end
-
-  def test_empty_empty_intersection
-    dr1 = Daterange.new
-    dr2 = Daterange.new
-    refute dr1.intersects?(dr2)
-    refute dr2.intersects?(dr1)
-  end
-
-  def test_merge
-    dr = Daterange.merge('2001, 30.04.2005, 2003,,')
-    assert_equal '01.01.2001 to 30.04.2005', dr.to_s
-  end
-
-  def test_comparison
-    dr1 = Daterange.new('01.04.2000')
-    dr2 = Daterange.new('01.04.2000 to 01.04.2000')
-    assert_equal dr1, dr2
-    assert_equal dr1, dr1.to_s
-    refute_equal nil, dr1
-    refute_equal 0, dr1
-    refute_equal dr1, nil
-    refute_equal dr1, 0
-  end
-
-  def test_three_char_months
-    dr1 = Daterange.new('01-APR-2020')
-    assert_equal '01.04.2020', dr1.date1.to_s
-    assert_equal '01.04.2020', dr1.date2.to_s
-
-    dr2 = Daterange.new('APR-2020')
-    assert_equal '01.04.2020', dr2.date1.to_s
-    assert_equal '30.04.2020', dr2.date2.to_s
-
-    dr3 = Daterange.new('JAN-2020 TO apr-2020')
-    assert_equal '01.01.2020', dr3.date1.to_s
-    assert_equal '30.04.2020', dr3.date2.to_s
-
-    dr4 = Daterange.new('20-JAN-2020 TO 12-Apr-2020')
-    assert_equal '20.01.2020', dr4.date1.to_s
-    assert_equal '12.04.2020', dr4.date2.to_s
-
-    dr5 = Daterange.new('01-BOB-2020')
-    assert_nil dr5.date1
-    assert_nil dr5.date2
-
-    dr6 = Daterange.new('01/APR/2020')
-    assert_equal '01.04.2020', dr6.date1.to_s
-    assert_equal '01.04.2020', dr6.date2.to_s
-
-    dr7 = Daterange.new('APR/2020')
-    assert_equal '01.04.2020', dr7.date1.to_s
-    assert_equal '30.04.2020', dr7.date2.to_s
-
-    dr8 = Daterange.new('JAN/2020 TO apr.2020')
-    assert_equal '01.01.2020', dr8.date1.to_s
-    assert_equal '30.04.2020', dr8.date2.to_s
-
-    dr9 = Daterange.new('20.JAN.2020 TO 12/Apr/2020')
-    assert_equal '20.01.2020', dr9.date1.to_s
-    assert_equal '12.04.2020', dr9.date2.to_s
-  end
-end

data/test/hash_test.rb

@@ -1,84 +0,0 @@
-require 'test_helper'
-
-# This tests our Hash extension
-class HashTest < Minitest::Test
-  test 'value_by_path' do
-    my_hash = { 'one' => '1', 'two' => { 'twopointone' => '2.1', 'twopointtwo' => '2.2' } }
-    assert_equal my_hash['one'], my_hash.value_by_path('one')
-    assert_equal my_hash['two']['twopointone'], my_hash.value_by_path('two', 'twopointone')
-  end
-
-  test 'intersection' do
-    my_hash = { :a => 1, :b => :two, 'c' => '3' }
-    assert_equal({ :a => 1, 'c' => '3' }, my_hash & [:a, :c])
-    assert_equal({ :b => :two }, my_hash & [:b])
-    assert_equal({}, my_hash & [:d, :e])
-  end
-
-  test 'rawtext_merge without prevent_overwrite' do
-    first_hash = { :a => 1, :b => :two, :rawtext => { 'x' => 'apples', 'y' => 'pears' } }
-    second_hash = { :b => 2, 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }
-    assert_equal(
-      {
-        :a => 1, :b => 2, 'c' => '3',
-        :rawtext => { 'x' => 'apples', 'y' => 'pears', 'z' => 'oranges' }
-      },
-      first_hash.rawtext_merge(second_hash, false)
-    )
-    # Ensure original hashes are preserved
-    assert_equal(
-      { :a => 1, :b => :two, :rawtext => { 'x' => 'apples', 'y' => 'pears' } }, first_hash
-    )
-    assert_equal(
-      { :b => 2, 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }, second_hash
-    )
-  end
-
-  test 'rawtext_merge with prevent_overwrite on rawtext' do
-    first_hash = { :a => 1, :b => :two, :rawtext => { 'x' => 'apples', 'y' => 'pears' } }
-    second_hash = { 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }
-    assert_raises RuntimeError do
-      first_hash.rawtext_merge(second_hash, true)
-    end
-    # Ensure original hashes are preserved
-    assert_equal(
-      { :a => 1, :b => :two, :rawtext => { 'x' => 'apples', 'y' => 'pears' } }, first_hash
-    )
-    assert_equal({ 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }, second_hash)
-  end
-
-  test 'rawtext_merge with prevent_overwrite on non-rawtext' do
-    first_hash = { :a => 1, :b => :two, :rawtext => { 'x' => 'apples' } }
-    second_hash = { :b => 2, 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }
-    assert_raises RuntimeError do
-      first_hash.rawtext_merge(second_hash, true)
-    end
-    # Ensure original hashes are preserved
-    assert_equal({ :a => 1, :b => :two, :rawtext => { 'x' => 'apples' } }, first_hash)
-    assert_equal(
-      { :b => 2, 'c' => '3', :rawtext => { 'y' => 'pears', 'z' => 'oranges' } }, second_hash
-    )
-  end
-
-  test 'rawtext_merge with one rawtext missing' do
-    first_hash = { :a => 1, :b => :two }
-    second_hash = { 'c' => '3', :rawtext => { 'x' => 'apples' } }
-    assert_equal({ :a => 1, :b => :two, 'c' => '3', :rawtext => { 'x' => 'apples' } },
-                 first_hash.rawtext_merge(second_hash, false))
-    assert_equal({ :a => 1, :b => :two, 'c' => '3', :rawtext => { 'x' => 'apples' } },
-                 second_hash.rawtext_merge(first_hash, false))
-    # Ensure original hashes are preserved
-    assert_equal({ :a => 1, :b => :two }, first_hash)
-    assert_equal({ 'c' => '3', :rawtext => { 'x' => 'apples' } }, second_hash)
-  end
-
-  test 'rawtext_merge with rawtext missing' do
-    first_hash = { :a => 1, :b => :two }
-    second_hash = { 'c' => '3' }
-    assert_equal({ :a => 1, :b => :two, 'c' => '3', :rawtext => {} },
-                 first_hash.rawtext_merge(second_hash, false))
-    # Ensure original hashes are preserved
-    assert_equal({ :a => 1, :b => :two }, first_hash)
-    assert_equal({ 'c' => '3' }, second_hash)
-  end
-end

data/test/integer/calculations_test.rb

@@ -1,28 +0,0 @@
-require 'test_helper'
-
-# This tests our Integer calculations extension
-class Integer::CalculationsTest < Minitest::Test
-  test 'Integer should be extended with #factorial' do
-    assert 1.respond_to?(:factorial)
-  end
-
-  test 'Integer#factorial should behave correctly' do
-    assert_equal 1, 0.factorial
-    assert_equal 24, 4.factorial
-    assert_raises(RuntimeError) { -1.factorial }
-  end
-
-  test 'Integer should be extended with #choose' do
-    assert 1.respond_to?(:choose)
-  end
-
-  test 'Integer#choose should behave correctly' do
-    pascal_row = [1, 5, 10, 10, 5, 1]
-    pascal_row.each_with_index do |target, index|
-      assert_equal target, 5.choose(index)
-    end
-
-    assert_raises(ArgumentError) { 10.choose(11) }
-    assert_raises(ArgumentError) { 10.choose(-1) }
-  end
-end