ndr_support 5.10.3 → 5.10.5

data/test/daterange_test.rb

@@ -1,307 +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 = if ActiveRecord.respond_to?(:default_timezone)
-                         ActiveRecord.default_timezone
-                       else
-                         ActiveRecord::Base.default_timezone # Rails <= 6.1
-                       end
-    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

data/test/integer/rounding_test.rb

@@ -1,14 +0,0 @@
-require 'test_helper'
-
-# This tests our rounding extension
-class Integer::RoundingTest < Minitest::Test
-  def test_rounding
-    assert_equal 124_000, 123_221.round_up_to(3)
-    assert_equal 123_300, 123_221.round_up_to(4)
-    assert_equal 760, 758.round_up_to(2)
-    assert_equal 3453, 3452.round_up_to(4)
-    assert_nil 1.round_up_to(2)
-    refute_nil 10.round_up_to(2)
-    assert_nil 12.round_up_to(-45)
-  end
-end

data/test/integer/working_days_test.rb

@@ -1,14 +0,0 @@
-require 'test_helper'
-
-# This tests our Integer working days extension
-class Integer::WorkingDaysTest < Minitest::Test
-  test 'Integer should be extended with #working_days_since' do
-    assert 1.respond_to?(:working_days_since)
-  end
-
-  test 'Integer#working_days_since should behave correctly' do
-    assert_equal Date.new(2019, 12, 23), 1.working_days_since(Date.new(2019, 12, 20))
-    assert_equal Date.new(2019, 12, 27), 3.working_days_since(Date.new(2019, 12, 20))
-    assert_equal Date.new(2019, 12, 30), 4.working_days_since(Date.new(2019, 12, 20))
-  end
-end

data/test/nil_test.rb

@@ -1,40 +0,0 @@
-require 'test_helper'
-
-# This tests our Nil extension
-class NilTest < Minitest::Test
-  test 'to_date' do
-    assert_nil nil.to_date
-  end
-
-  test 'titleize' do
-    assert_nil nil.titleize
-  end
-
-  test 'surnameize' do
-    assert_nil nil.surnameize
-  end
-
-  test 'postcodeize' do
-    assert_nil nil.postcodeize
-  end
-
-  test 'upcase' do
-    assert_nil nil.upcase
-  end
-
-  test 'clean' do
-    assert_nil nil.clean(:tnmcategory)
-  end
-
-  test 'squash' do
-    assert_nil nil.squash
-  end
-
-  test 'gsub' do
-    assert_equal '', nil.gsub(/.*/)
-  end
-
-  test 'strip' do
-    assert_nil nil.strip
-  end
-end

data/test/obfuscator_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-# Tests obfuscation library
-class ObfuscatorTest < Minitest::Test
-  test 'deterministic seed should give consistent obfuscation' do
-    seed1 = 1383023878118423080153274094615300156
-    assert_equal 'CE PSEQQH', NdrSupport::Obfuscator.obfuscate('JO BLOGGS', seed1)
-    assert_equal 'CE PSEQQH', NdrSupport::Obfuscator.obfuscate('JO BLOGGS', seed1),
-                 'consistent re-obfuscation'
-    assert_equal 'CE PSEQQH', NdrSupport::Obfuscator.obfuscate('Jo Bloggs', seed1),
-                 'case insensitive'
-    assert_equal 'CEZG PTIQQH', NdrSupport::Obfuscator.obfuscate('JOHN BRIGGS', seed1)
-  end
-
-  test 'different seeds should obfuscate differently' do
-    seed2 = 33333285080880515415022777373811069493
-    assert_equal 'VI RQICCZ', NdrSupport::Obfuscator.obfuscate('JO BLOGGS', seed2)
-  end
-
-  test 'test seed setup' do
-    seed3 = 24978785977027615655244702873942606627
-    assert_equal '781 RACO RXHOOX', NdrSupport::Obfuscator.obfuscate('369 Some Street', seed3)
-    NdrSupport::Obfuscator.setup(seed3)
-    assert_equal '781 RACO RXHOOX', NdrSupport::Obfuscator.obfuscate('369 Some Street')
-  end
-end

data/test/ourdate_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-# This tests our Ourdate class
-class OurdateTest < Minitest::Test
-  def test_date_and_time
-    d = Ourdate.build_datetime(2003, 11, 30)
-    assert_equal '2003-11-30', d.to_iso
-    assert_equal '30.11.2003', d.to_formatted_s
-    assert_equal '30.11.2003', d.to_s
-  end
-
-  def test_ourdate
-    # Creating an Ourdate from a String
-    od = Ourdate.new('01.02.2000')
-    assert_equal Date.new(2000, 2, 1).to_formatted_s(:ui), od.to_s
-    assert_kind_of Date, od.thedate
-    assert_equal '01.02.2000', od.thedate.to_s
-    # Creating an Ourdate from a Date
-    od = Ourdate.new(Date.new(2000, 3, 1))
-    assert_equal '01.03.2000', od.to_s
-  end
-
-  def test_blank
-    assert Ourdate.new.blank?  # delegates to empty?
-  end
-end

data/test/ourtime_test.rb

@@ -1,45 +0,0 @@
-require 'test_helper'
-
-# This tests our Ourtime class
-class OurtimeTest < Minitest::Test
-  def test_initialize_with_local_format_string_gmt
-    # Creating an Ourtime from a local-format String (with seconds)
-    ot = Ourtime.new('01.02.1993 04:05:06')
-    assert_equal '1993-02-01 04:05:06', ot.thetime.strftime('%Y-%m-%d %H:%M:%S')
-    assert_kind_of Time, ot.thetime
-    assert_equal 0.hours, ot.thetime.gmt_offset
-  end
-
-  def test_initialize_with_local_format_string_bst
-    # Creating an Ourtime from a local-format String (with seconds)
-    ot = Ourtime.new('01.08.1993 04:05:06')
-    assert_equal '1993-08-01 04:05:06', ot.thetime.strftime('%Y-%m-%d %H:%M:%S')
-    assert_kind_of Time, ot.thetime
-    assert_equal 1.hours, ot.thetime.gmt_offset
-  end
-
-  def test_initialize_with_time
-    # Creating an Ourtime from a Time
-    ot = Ourtime.new(Time.mktime(1993, 2, 1, 4, 5))
-    assert_equal '01.02.1993 04:05', ot.to_s
-    assert_equal 0.hours, ot.thetime.gmt_offset
-  end
-
-  def test_initialize_with_no_parameters
-    assert Ourtime.new.blank?  # delegates to empty?
-  end
-
-  def test_initialize_with_iso_string_bst
-    # Parsing an ISO datetime
-    ot = Ourtime.new('1993-05-05 06:07:08')
-    assert_equal '1993-05-05 06:07:08', ot.thetime.strftime('%Y-%m-%d %H:%M:%S')
-    assert_equal 1.hours, ot.thetime.gmt_offset
-  end
-
-  def test_initialize_with_iso_string_gmt
-    # Parsing an ISO datetime
-    ot = Ourtime.new('1993-01-05 06:07:08')
-    assert_equal '1993-01-05 06:07:08', ot.thetime.strftime('%Y-%m-%d %H:%M:%S')
-    assert_equal 0.hours, ot.thetime.gmt_offset
-  end
-end