ndr_support 5.10.4 → 5.10.5

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

data/test/password_test.rb

@@ -1,129 +0,0 @@
-require 'test_helper'
-
-# Tests password generation and checking library
-class PasswordTest < Minitest::Test
-  test 'checking length requirement' do
-    refute NdrSupport::Password.valid?('acegi')
-    assert NdrSupport::Password.valid?('acegik')
-  end
-
-  test 'checking character uniqueness requirement' do
-    refute NdrSupport::Password.valid?('acegacegacegacegacegacegaceg')
-    assert NdrSupport::Password.valid?('acefhacefhacefhacefhacefhace')
-  end
-
-  test 'when checking, dictionary words are considered' do
-    refute NdrSupport::Password.valid?('google password')
-    assert NdrSupport::Password.valid?('google the password')
-  end
-
-  test 'when checking, custom dictionary words are considered' do
-    refute NdrSupport::Password.valid?('google passphrase',     word_list: ['passphrase'])
-    assert NdrSupport::Password.valid?('google the passphrase', word_list: ['passphrase'])
-  end
-
-  test 'when checking, custom dictionary words that are also sequences are not over-counted' do
-    refute NdrSupport::Password.valid?('hijkl a ',  word_list: %w(hijkl hijklm))
-    refute NdrSupport::Password.valid?('hijklm a ', word_list: %w(hijkl hijklm))
-  end
-
-  test 'when checking, custom dictionary words substrings of others should not intefere' do
-    refute NdrSupport::Password.valid?('acegik a', word_list: %w(cegi acegik))
-    refute NdrSupport::Password.valid?('acegik a', word_list: %w(acegik cegi))
-  end
-
-  test 'checking blank input' do
-    refute NdrSupport::Password.valid?(nil)
-    refute NdrSupport::Password.valid?('')
-    refute NdrSupport::Password.valid?('                    ')
-  end
-
-  test 'checking with increasing sequences' do
-    refute NdrSupport::Password.valid?('12345678')
-    refute NdrSupport::Password.valid?('1234 5678')
-    refute NdrSupport::Password.valid?('456789')
-    refute NdrSupport::Password.valid?('456 789')
-    refute NdrSupport::Password.valid?('abcdefghijk')
-    refute NdrSupport::Password.valid?('abcde fghijk')
-    refute NdrSupport::Password.valid?('BCDEFGHIJKL')
-    refute NdrSupport::Password.valid?('BCDEFG HIJKL')
-
-    assert NdrSupport::Password.valid?('more 1234 5678')
-    assert NdrSupport::Password.valid?('1234 more 5678')
-    assert NdrSupport::Password.valid?('1234 5678 more')
-  end
-
-  test 'checking with decreasing sequences' do
-    refute NdrSupport::Password.valid?('87654321')
-    refute NdrSupport::Password.valid?('8765 4321')
-    refute NdrSupport::Password.valid?('987654')
-    refute NdrSupport::Password.valid?('987 654')
-    refute NdrSupport::Password.valid?('kjihgfedcba')
-    refute NdrSupport::Password.valid?('kjihg fedcba')
-    refute NdrSupport::Password.valid?('LKJIHGFEDCB')
-    refute NdrSupport::Password.valid?('LKJIHG FEDCB')
-
-    assert NdrSupport::Password.valid?('more 8765 4321')
-    assert NdrSupport::Password.valid?('8765 more 4321')
-    assert NdrSupport::Password.valid?('8765 4321 more')
-  end
-
-  test 'checking with increasing then decreasing sequences' do
-    refute NdrSupport::Password.valid?('123456787654321')
-    refute NdrSupport::Password.valid?('aBcDeFgFeDcBa')
-
-    assert NdrSupport::Password.valid?('something 123456787654321')
-    assert NdrSupport::Password.valid?('something aBcDeFgFeDcBa')
-  end
-
-  test 'checking with decreasing then increasing sequences' do
-    refute NdrSupport::Password.valid?('876543212345678')
-    refute NdrSupport::Password.valid?('gFeDcBaBcDeFg')
-
-    assert NdrSupport::Password.valid?('something 876543212345678')
-    assert NdrSupport::Password.valid?('something gFeDcBaBcDeFg')
-  end
-
-  test 'checking with repeating characters' do
-    refute NdrSupport::Password.valid?('happen')
-    assert NdrSupport::Password.valid?('happens')
-    assert NdrSupport::Password.valid?('hapqren')
-    assert NdrSupport::Password.valid?('hapqsen')
-
-    refute NdrSupport::Password.valid?('balloon')
-    refute NdrSupport::Password.valid?('ballllLLLllLLLllllooooOOooOOoooon')
-    assert NdrSupport::Password.valid?('baileon')
-  end
-
-  test 'generating' do
-    password = NdrSupport::Password.generate
-
-    assert NdrSupport::Password.valid?(password)
-    assert_equal 4, password.split(/\s/).length
-
-    password.scan(/\w+/) { |wd| assert NdrSupport::Password::RFC1751_WORDS.include?(wd.upcase) }
-  end
-
-  test 'generating with custom length' do
-    password = NdrSupport::Password.generate(number_of_words: 6)
-
-    assert NdrSupport::Password.valid?(password)
-    assert_equal 6, password.split(/\s/).length
-
-    password.scan(/\w+/) { |wd| assert NdrSupport::Password::RFC1751_WORDS.include?(wd.upcase) }
-  end
-
-  test 'generating with custom separator' do
-    password = NdrSupport::Password.generate(separator: '-')
-
-    assert NdrSupport::Password.valid?(password)
-    assert_equal 4, password.split(/-/).length
-
-    password.scan(/\w+/) { |wd| assert NdrSupport::Password::RFC1751_WORDS.include?(wd.upcase) }
-  end
-
-  test 'generating unrealistically' do
-    exception = assert_raises(RuntimeError) { NdrSupport::Password.generate(number_of_words: 1) }
-    assert_match(/failed to generate/i, exception.message)
-  end
-end

data/test/regexp_range_test.rb

@@ -1,136 +0,0 @@
-require 'test_helper'
-
-# This tests our RegexpRange class
-class RegexpRangeTest < Minitest::Test
-  def setup
-    @lines = [
-      '0Lorem ipsum dolor sit amet',
-      '1consectetur adipisicing elit',
-      '2sed do eiusmod tempor incididunt ut labore et dolore magna aliqua',
-      '3Ut enim ad minim veniam, quis nostrud exercitation ullamco',
-      '4laboris nisi ut aliquip ex ea commodo consequat'
-    ]
-  end
-
-  test 'to_yaml' do
-    regexp_range = RegexpRange.new(0, /^3Ut/)
-
-    # Don't test YAML serialisation directly, but make it can be loaded:
-    deserialized_regexp_range = YAML.safe_load(regexp_range.to_yaml,
-                                               permitted_classes: [RegexpRange, Regexp])
-    assert_instance_of RegexpRange, deserialized_regexp_range
-    assert_equal regexp_range.begin, deserialized_regexp_range.begin
-    assert_equal regexp_range.end, deserialized_regexp_range.end
-    assert_equal regexp_range.excl, deserialized_regexp_range.excl
-  end
-
-  test 'to_range with number and number' do
-    assert_equal Range.new(2, 3, true), RegexpRange.new(2, 3, true).to_range(@lines)
-    assert_equal Range.new(2, 3, false), RegexpRange.new(2, 3, false).to_range(@lines)
-    assert_equal Range.new(0, -1, true), RegexpRange.new(0, -1, true).to_range(@lines)
-    assert_equal Range.new(0, -1, false), RegexpRange.new(0, -1, false).to_range(@lines)
-
-    assert_equal @lines[Range.new(2, 3, true)],
-                 @lines[RegexpRange.new(2, 3, true).to_range(@lines)]
-    assert_equal @lines[Range.new(2, 3, false)],
-                 @lines[RegexpRange.new(2, 3, false).to_range(@lines)]
-  end
-
-  test 'to_range with number and regexp' do
-    assert_equal Range.new(2, 3, true), RegexpRange.new(2, /^3Ut/, true).to_range(@lines)
-    assert_equal Range.new(2, 3, false), RegexpRange.new(2, /^3Ut/, false).to_range(@lines)
-
-    assert_equal @lines[Range.new(2, 3, true)],
-                 @lines[RegexpRange.new(2, /^3Ut/, true).to_range(@lines)]
-    assert_equal @lines[Range.new(2, 3, false)],
-                 @lines[RegexpRange.new(2, /^3Ut/, false).to_range(@lines)]
-
-    assert_raises RegexpRange::PatternMatchError do
-      RegexpRange.new(2, /^NO_MATCH$/, true).to_range(@lines)
-    end
-    assert_raises RegexpRange::PatternMatchError do
-      RegexpRange.new(2, /^NO_MATCH$/, false).to_range(@lines)
-    end
-  end
-
-  test 'to_range with regexp and number' do
-    assert_equal Range.new(1, -1, true), RegexpRange.new(/^1consec/, -1, true).to_range(@lines)
-    assert_equal Range.new(1, -1, false), RegexpRange.new(/^1consec/, -1, false).to_range(@lines)
-    assert_equal Range.new(1, 5, true), RegexpRange.new(/^1consec/, 5, true).to_range(@lines)
-    assert_equal Range.new(1, 5, false), RegexpRange.new(/^1consec/, 5, false).to_range(@lines)
-
-    assert_equal @lines[Range.new(1, -1, true)],
-                 @lines[RegexpRange.new(/^1consec/, -1, true).to_range(@lines)]
-    assert_equal @lines[Range.new(1, -1, false)],
-                 @lines[RegexpRange.new(/^1consec/, -1, false).to_range(@lines)]
-
-    assert_raises RegexpRange::PatternMatchError do
-      RegexpRange.new(/^NO_MATCH$/, 5, true).to_range(@lines)
-    end
-    assert_raises RegexpRange::PatternMatchError do
-      RegexpRange.new(/^NO_MATCH$/, 5, false).to_range(@lines)
-    end
-  end
-
-  test 'to_range with regexp and regexp' do
-    assert_equal Range.new(1, 3, true),
-                 RegexpRange.new(/^1consec/, /^3Ut/, true).to_range(@lines)
-    assert_equal Range.new(1, 3, false),
-                 RegexpRange.new(/^1consec/, /^3Ut/, false).to_range(@lines)
-
-    assert_equal @lines[Range.new(1, 3, true)],
-                 @lines[RegexpRange.new(/^1consec/, /^3Ut/, true).to_range(@lines)]
-    assert_equal @lines[Range.new(1, 3, false)],
-                 @lines[RegexpRange.new(/^1consec/, /^3Ut/, false).to_range(@lines)]
-
-    assert_raises RegexpRange::PatternMatchError do
-      RegexpRange.new(/^NO_MATCH$/, /^NO_MATCH$/, true).to_range(@lines)
-    end
-    assert_raises RegexpRange::PatternMatchError do
-      RegexpRange.new(/^NO_MATCH$/, /^NO_MATCH$/, false).to_range(@lines)
-    end
-  end
-
-  test 'comparison to self' do
-    rr1 = RegexpRange.new(/start/, /end/, false)
-    assert_equal rr1, rr1
-  end
-
-  test 'comparison to identical regexprange' do
-    rr1 = RegexpRange.new(/start/, /end/, false)
-    rr2 = RegexpRange.new(/start/, /end/, false)
-    assert_equal rr1, rr2
-  end
-
-  test 'comparison to different regexprange' do
-    rr1 = RegexpRange.new(/start/, /end/, false)
-    rr2 = RegexpRange.new(/start/, /end/, true)
-    refute_equal rr1, rr2
-
-    rr3 = RegexpRange.new(/start/, /end/, false)
-    rr4 = RegexpRange.new(/start/, /finish/, false)
-    refute_equal rr3, rr4
-
-    rr5 = RegexpRange.new(/start/, /end/, true)
-    rr6 = RegexpRange.new(/begin/, /end/, true)
-    refute_equal rr5, rr6
-  end
-
-  test 'hash key comparison' do
-    rr1 = RegexpRange.new(/start/, /end/, false)
-    rr2 = RegexpRange.new(/start/, /end/, false)
-    rr3 = RegexpRange.new(/start/, /end/, true)
-
-    hash = Hash.new { |h, k| h[k] = 0 }
-
-    hash[rr1] += 1
-    hash[rr2] += 1
-    hash[rr3] += 1
-
-    assert_equal 2, hash.keys.length
-
-    assert_equal 2, hash[rr1]
-    assert_equal 2, hash[rr2]
-    assert_equal 1, hash[rr3]
-  end
-end

data/test/resources/filesystem_paths.yml

@@ -1,37 +0,0 @@
-# This allows us different filesystem paths for different platforms
---- 
-test_files: &test_files
-  root: <%= Dir.mktmpdir %>
-
-? !ruby/regexp /.*/
-: 
-  dbs_outbox: 
-    root: "/mounts/ron/dbs_outbox"
-    prms:
-      - r
-      - w
-      - x
-  broken_space:
-    root: "potato"
-    prms:
-      - r
-      - w
-      - x
-  test_space_r:
-    <<: *test_files
-    prms:
-      - r
-  test_space_w:
-    <<: *test_files
-    prms:
-      - w
-  test_space_rw:
-    <<: *test_files
-    prms:
-      - r
-      - w
-  permanent_test_files:
-    root: <%#= Rails.root.join("test","unit","files") %>
-    prms:
-      - r
-      - w